input: Write a function to solve a maze using an object-oriented approach in Python. The function should create a Maze class with methods to initialize the maze, solve the maze, and find the path from the start to the end. The input to the function should be the dimensions of the maze and the maze grid, and the output should be the path from the start to the end if it exists.
  
  import collections
  
  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):
          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
  
  assert Maze(5, 5).solve_maze() == []
  assert Maze(3, 3).solve_maze() == []
  assert Maze(1, 1).solve_maze() == []
  assert Maze(4, 4).solve_maze() == []
  assert Maze(0, 0).solve_maze() == []
  
output: 
  def __init__(self, n, m, grid):
      self._n, self._m = n, m
      self._grid = grid
  
  def solve_maze(self):
      start, end = (0, 0), (self._n-1, self._m-1)
      queue = collections.deque([(start, [start])])
      visited = set()
  
      while queue:
          (current, path) = queue.popleft()
          if current == end:
              return path
          visited.add(current)
          for neighbor in self._get_neighbors(current):
              if neighbor not in visited:
                  queue.append((neighbor, path + [neighbor]))
      return []
  
  def _get_neighbors(self, pos):
      row, col = pos
      neighbors = []
      for dr, dc in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
          nr, nc = row + dr, col + dc
          if 0 <= nr < self._n and 0 <= nc < self._m and self._grid[nr][nc] == 1:
              neighbors.append((nr, nc))
      return neighbors
  