Problem:
Surrounding Area

土地囲い

English text is not available in this practice contest.

ある 2 人の不動産屋が，客船に乗って南の島に向かっていた．青い空，さわやかな風…．2 人は他の乗客とともに船旅を楽しんでいた．ところが，ある日突然発生した竜巻によって客船が沈んでしまった．他の乗客は救助隊によって救助されたが，どういうわけかこの 2 人だけ見落とされてしまった．数日の漂流の後，彼らはある無人島に流れ着いた．この無人島は長方形であり，以下の図のように格子に区切られていた．

図 C-1: 無人島の形状

彼らはとても欲深かったので，助けを呼ぶことではなく，この無人島の土地を売ることを考えていた．そして，彼らは土地を折半するということはせず，土地の奪い合いを始めた．彼らはそれぞれ自分の土地にしたいところを，一方は黒い杭で，もう一方は白い杭で囲み始めた．全ての杭は格子の中央に打たれ，また 1 つの格子に複数の杭が打たれることはなかった．しばらくすると双方とも疲れ果てて，杭を打つことを止めた．

あなたの仕事は，黒い杭および白い杭で囲まれた土地の面積を求めるプログラムを書くことである．ただし，格子 (i, j) が黒い杭に囲まれているとは，直感的には「格子 (i, j) から上下左右に任意に移動したとき，最初に当たる杭は常に黒い杭である」ことを意味する．正確には以下のように定義される．

黒い杭に「拡大隣接した」格子を次のとおりに定める．白い杭についても同様とする．

格子 (i, j) に杭が存在せず，さらに格子 (i, j) に隣接する格子のいずれかに黒い杭が存在するならば，格子 (i, j) は黒い杭に拡大隣接している．

格子 (i, j) に杭が存在せず，さらに格子 (i, j) に隣接する格子のいずれかが黒い杭に拡大隣接しているならば，格子 (i, j) は黒い杭に拡大隣接している．このルールは再帰的に適用される．

このとき，格子 (i, j) が黒い杭に拡大隣接していて，さらに白い杭に隣接していないとき，またそのときに限って，格子 (i, j) が黒い杭に囲まれているという．また逆に，格子 (i, j) が白い杭に拡大隣接していて，さらに黒い杭に隣接していないとき，またそのときに限って，格子 (i, j) が白い杭に囲まれているという．

Input

入力は複数のデータセットから構成される．各データセットは以下のような構成になっている．

w h

a1,1 a2,1 a3,1 ... aw,1

a1,2 a2,2 a3,2 ... aw,2

...

a1,h a2,h a3,h ... aw,h

w は土地の横幅，h は土地の縦幅を表す．これらは 1 ≦ w,h ≦ 50 を満たす．各 ai,j は格子 (i, j) の状態を表す 1 つの半角文字であり，「B」は黒い杭が打たれていることを，「W」は白い杭が打たれていることを，「.」（ピリオド）はいずれの杭も打たれていないことをそれぞれ示す．

w = h = 0 は入力の終端を表しており，データセットには含まれない．

Output

各データセットについて，黒い杭が囲んだ土地の大きさ，および白い杭が囲んだ土地の大きさを 1 つの空白で区切って 1 行に出力しなさい．

Sample Input

10 10
.....W....
....W.W...
...W...W..
....W...W.
.....W...W
......W.W.
BBB....W..
..B..BBBBB
..B..B....
..B..B..W.
5 3
...B.
...BB
.....
1 1
.
0 0

Output for the Sample Input

6 21
12 0
0 0

Solution in JAVA (judge verdict: Accepted)

import java.util.ArrayList;
import java.util.Scanner;

public class Main {

	static char[][] a;
	static char[][] wMap;
	static char[][] bMap;
	static int[][] directions8 = { { -1, -1 }, { -1, 0 }, { -1, 1 }, { 0, -1 }, { 0, 1 }, { 1, -1 }, { 1, 0 },
			{ 1, 1 } };
	static int[][] directions4 = { { -1, 0 }, { 1, 0 }, { 0, -1 }, { 0, 1 } };
	static int ans;
	static int countW;
	static int countB;
	static int w;
	static int h;
	static boolean[][] wSquare;
	static boolean[][] bSquare;

	public static void main(String[] args) {

		Scanner sc = new Scanner(System.in);

		while (true) {

			w = sc.nextInt();
			h = sc.nextInt();

			if ((w | h) == 0) {
				break;
			}
			a = new char[h][w];
			wMap = new char[h][w];
			bMap = new char[h][w];
			wSquare = new boolean[h][w];
			bSquare = new boolean[h][w];

			for (int i = 0; i < h; i++) {
				String s = sc.next();
				for (int j = 0; j < w; j++) {
					// a[タテ][ヨコ]
					a[i][j] = s.charAt(j);
					wMap[i][j] = a[i][j];
					bMap[i][j] = a[i][j];
				}
			}
			for (int i = 0; i < h; i++) {
				for (int j = 0; j < w; j++) {
					if (a[i][j] == 'B') {
						for (int k = 0; k < 4; k++) {
							countB(i + directions4[k][0], j + directions4[k][1]);
						}
						countB(i, j);
					} else if (a[i][j] == 'W') {
						for (int k = 0; k < 4; k++) {
							countW(i + directions4[k][0], j + directions4[k][1]);
						}
					}
				}
			}
			countB = 0;
			countW = 0;
			for (int i = 0; i < h; i++) {
				for (int j = 0; j < w; j++) {
					if (bSquare[i][j] && !wSquare[i][j]) {
						countB++;
					} else if (!bSquare[i][j] && wSquare[i][j]) {
						countW++;
					}
				}
			}
			System.out.println(countB + " " + countW);
		}

	}

	static void countW(int thisH, int thisW) {
		if (thisH >= h || thisH < 0 || thisW >= w || thisW < 0 || wSquare[thisH][thisW] || wMap[thisH][thisW] != '.') {
			return;
		}
		// wMap[thisH][thisW] = 'W';
		wSquare[thisH][thisW] = true;

		for (int i = 0; i < 4; i++) {
			countW(thisH + directions4[i][0], thisW + directions4[i][1]);
		}
	}

	static void countB(int thisH, int thisW) {
		if (thisH >= h || thisH < 0 || thisW >= w || thisW < 0 || bSquare[thisH][thisW] || bMap[thisH][thisW] != '.') {
			return;
		}
		bSquare[thisH][thisW] = true;

		for (int i = 0; i < 4; i++) {
			countB(thisH + directions4[i][0], thisW + directions4[i][1]);
		}
	}

	// BFS用に二つの配列を足し算する
	static int[] addArrayElms(int[] a, int[] b) {
		int[] c = new int[a.length];
		for (int i = 0; i < a.length; i++) {
			c[i] = a[i] + b[i];
		}
		return c;
	}

	// //二分探索
	// k <= num となる最小の配列要素kのインデックスを返す
	static private int binarySearch(long num, long[] orderedArray) {
		int lowerBorder = -1;
		int upperBorder = orderedArray.length;
		int mid;

		while (upperBorder - lowerBorder > 1) {
			mid = (upperBorder + lowerBorder) / 2;
			if (orderedArray[mid] <= num) {
				lowerBorder = mid;
			} else {
				upperBorder = mid;
			}
		}
		return lowerBorder;
	}

	// 二分探索
	// k <= num となる最小のList要素kのインデックスを返す
	static private int binarySearch(long num, ArrayList<Long> orderedList) {
		int lowerBorder = -1;
		int upperBorder = orderedList.size();
		int mid;

		while (upperBorder - lowerBorder > 1) {
			mid = (upperBorder + lowerBorder) / 2;
			if (orderedList.get(mid) <= num) {
				lowerBorder = mid;
			} else {
				upperBorder = mid;
			}
		}
		return lowerBorder;
	}

	// aとbの最小公倍数を求める
	public static int gcd(int a, int b) {
		return b == 0 ? a : gcd(b, a % b);
	}

	public static long gcd(long a, long b) {
		return b == 0 ? a : gcd(b, a % b);
	}
}