output_description: For each data set, your program should output a line which contains the number
  of tiles he can reach from the initial tile (including itself).
input_description: The input consists of multiple data sets. A data set starts with a line
  containing two positive integers _W_ and _H_ ; _W_ and _H_ are the numbers of
  tiles in the _x_ \- and _y_ \- directions, respectively. _W_ and _H_ are not
  more than 20.
  
  There are _H_ more lines in the data set, each of which includes _W_
  characters. Each character represents the color of a tile as follows.
  
    * '.' - a black tile 
    * '#' - a red tile 
    * '@' - a man on a black tile(appears exactly once in a data set) 
  
  The end of the input is indicated by a line consisting of two zeros.
attempt: #!/usr/bin/env python3
  # -*- coding: utf-8 -*-
  
  import array
  import collections
  import itertools
  
  
  class DepthFirstSearchWithStack(object):
  
      def __init__(self, width, height, tiles):
          self.width = width
          self.height = height
          self.tiles = tiles
          self.reached = [
              array.array("B", (False for y in range(height))) for x in range(width)
          ]
          for x, y in itertools.product(range(width), range(height)):
              if tiles[x][y] == "@":
                  self.start_tile = (x, y)
                  break
  
      def search(self, x0, y0):
          stack = collections.deque()
          self.reached[x0][y0] = True
          stack.append((x0, y0))
          while stack:
              (x, y) = stack.pop()
              for i, j in [(x + 1, y), (x - 1, y), (x, y + 1), (x, y - 1)]:
                  if i < 0 or self.width <= i or j < 0 or self.height <= j:
                      pass
                  elif self.tiles[i][j] == "#":
                      pass
                  elif not self.reached[i][j]:
                      self.reached[i][j] = True
                      stack.append((i, j))
  
      def count_reachable_tiles(self):
          self.search(*self.start_tile)
          reachable_tiles = sum(
              [
                  self.reached[x][y]
                  for x, y in itertools.product(range(self.width), range(self.height))
              ]
          )
          return reachable_tiles
  
  
  if __name__ == "__main__":
      while True:
          width, height = map(int, input().split())
          if width == 0 and height == 0:
              break
          else:
              tiles = [x for x in zip(*[input() for y in range(height)])]
              dfs = DepthFirstSearchWithStack(width, height, tiles)
              print(dfs.count_reachable_tiles())
  
problem_description: B: Red and Black
  
  There is a rectangular room, covered with square tiles. Each tile is colored
  either red or black. A man is standing on a black tile. From a tile, he can
  move to one of four adjacent tiles. But he can't move on red tiles, he can
  move only on black tiles.
  
  Write a program to count the number of black tiles which he can reach by
  repeating the moves described above.
samples: [{"input": "9\n    ....#.\n    .....#\n    ......\n    ......\n    ......\n    ......\n    ......\n    #@...#\n    .#..#.\n    11 9\n    .#.........\n    .#.#######.\n    .#.#.....#.\n    .#.#.###.#.\n    .#.#..@#.#.\n    .#.#####.#.\n    .#.......#.\n    .#########.\n    ...........\n    11 6\n    ..#..#..#..\n    ..#..#..#..\n    ..#..#..###\n    ..#..#..#@.\n    ..#..#..#..\n    ..#..#..#..\n    7 7\n    ..#.#..\n    ..#.#..\n    ###.###\n    ...@...\n    ###.###\n    ..#.#..\n    ..#.#..\n    0 0", "output": "59\n    6\n    13"}]