Problem:
Problem 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.

Input

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.

Output

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).

Sample Input

6 9
....#.
.....#
......
......
......
......
......
#@...#
.#..#.
11 9
.#.........
.#.#######.
.#.#.....#.
.#.#.###.#.
.#.#..@#.#.
.#.#####.#.
.#.......#.
.#########.
...........
11 6
..#..#..#..
..#..#..#..
..#..#..###
..#..#..#@.
..#..#..#..
..#..#..#..
7 7
..#.#..
..#.#..
###.###
...@...
###.###
..#.#..
..#.#..
0 0

Output for the Sample Input

45
59
6
13

Solution in C# (judge verdict: Accepted)

using System;
using System.Collections;
using System.Collections.Generic;

public class AOJ11
{
    public static void Main()
    {
        int W, H;
        string[] field = new string[20];
        int[] dx = { -1, 0, 1, 0 };
        int[] dy = { 0, -1, 0, 1 };
        Queue q = new Queue();
        while (true)
        {
            string[] v = Console.ReadLine().Split(' ');
            W = Int32.Parse(v[0]); H = Int32.Parse(v[1]);
            if (W == 0 && H == 0) break;
            for (int i = 0; i < H; i++) field[i] = Console.ReadLine();
            bool[,] flag = new bool[H, W];
            for (int i = 0; i < H; i++)
            {
                for (int j = 0; j < W; j++)
                {
                    if (field[i][j] == '@')
                    {
                        q.Enqueue(new KeyValuePair<int, int>(i, j));
                        flag[i, j] = true;
                        goto stop;
                    }
                }
            }
        stop:
            while (q.Count > 0)
            {
                KeyValuePair<int, int> T = (KeyValuePair<int, int>)q.Peek();
                int y = T.Key; int x = T.Value;
                q.Dequeue();
                for (int i = 0; i < 4; i++)
                {
                    if (x + dx[i] < 0 || W <= x + dx[i] || y + dy[i] < 0 || H <= y + dy[i]) continue;
                    if (field[y + dy[i]][x + dx[i]] == '#' || flag[y + dy[i], x + dx[i]] == true) continue;
                    flag[y + dy[i], x + dx[i]] = true;
                    q.Enqueue(new KeyValuePair<int, int>(y + dy[i], x + dx[i]));
                }
            }
            int cnt = 0;
            for (int i = 0; i < H; i++) for (int j = 0; j < W; j++) if (flag[i, j] == true) cnt++;
            Console.WriteLine(cnt);
        }
    }
}