개임판 덮기 문제

package algorithm.boardcover;

import java.util.Scanner;

public class BoardCover {
//주어진 칸을 덮을 수 있는 네 가지 방법
//블록을 구성하는 세 칸의 상대적 위치(dy, dx)의 목록
private static final int coverType[][][] = { { {0, 0}, {1, 0}, {0, 1} },{ {0, 0}, {0, 1}, {1, 1} },{ {0, 0}, {1, 0}, {1, 1} },{ {0, 0}, {1, 0}, {1, -1} }
};
/*
 (0,-1) (0,0) (0,1)
 (1,-1) (1,0) (1,1)
 */
public static void main(String[] args) {
	Scanner sc = new Scanner(System.in);
	//테스트 케이스.
	System.out.print("테스트 케이스?(C<=30):");
	int C = sc.nextInt();
	//결과를 반환할 배열 선언.
	int result[] = new int[C];
	//board 선언.
	int board[][];
	//테스트 케이스만큼 반복.
	for(int i = 0; i < C; ++i) {
		//세로축 입력(행).
		System.out.print("H(1<=H):");
		int H = sc.nextInt();
		//가로축 입력(열).
		System.out.print("W(W<=20):");
		int W = sc.nextInt();
		//입력받은 보드판 크기 할당.
		board = new int[H][W];
		for(int j = 0; j < H; ++j) {
			System.out.print("#은 검은 칸, .는 흰 칸:");
			String cover = sc.next();
			for(int k = 0; k < W; ++k) {
				//board[i][j] = 1 검은 칸, board[i][j] = 0 아직 덮이지 않은 칸.
				board[j][k] = (cover.charAt(k) == '#') ? 1: 0;
			}
		}
		//경의수 구함.
		result[i] = cover(board);
	}
	//테스트 케이스 수만큼 반복.
	for(int i = 0; i < result.length; ++i) {
		//결과 출력.
		System.out.println("결과 : " + result[i]);
	}
	sc.close();
}

//board의 (y, x)를 type번 방법으로 덮거나, 덮었던 블록을 없앤다.
//delta = 1이면 덮고, -1이면 덮었던 블록을 없앤다.
//만약 블록이 제대로 덮이지 않은 경우 (게임판 밖으로 나가거나, 겹치거나, 같은 칸을 덮을 때) false를 반환한다.
private static boolean set(int[][] board, int y, int x, int type, int delta) {
	boolean ok = true;
	//L자를 만들 수 있는 형태만큼 반복
	for(int i = 0; i < 3; ++i) {
		//y의 변화량 = 해당 칸의 y인덱스 + y의 변화 타입.
		final int ny = y + coverType[type][i][0];
		//x의 변화량 = 해당 칸의 x인덱스 + x의 변화 타입.
		final int nx = x + coverType[type][i][1];
		//게임판 밖으로 나가거나, 겹치면, false를 반환한다.
		if(ny < 0 || ny >= board.length || nx < 0 || nx >= board[0].length) {
			ok = false;
		//delta가 -1이면 값은 항상 1이 나오므로, false를 반환한다.
		}else if((board[ny][nx] += delta) > 1) {
			ok = false;
		}
	}
	return ok;
}

//board의 모든 빈 칸을 덮을 수 있는 방법의 수를 반환한다.
//board[i][j] = 1 이미 덮인 칸 혹은 검은 칸.
//board[i][j] = 0 아직 덮이지 않은 칸.
private static int cover(int[][] board) {
	//아직 채우지 못한 칸 중 가장 윗줄 왼쪽에 있는 칸을 찾는다.
	int y = -1, x = -1;
	//보드의 크기(행)만큼 반복.
	for(int i = 0; i < board.length; ++i) {
		//각 행에 해당하는 크기(열)만큼 반복.
		for(int j = 0; j < board[i].length; ++j) {
			//아직 덮이지 않은 칸이라면.
			if(board[i][j] == 0) {
				//덮이지 않은 칸의 인덱스를 할당.
				y = i;
				x = j;
				break;
			}
		}
		//가장 윗줄 칸이 아닐 경우 반복 중지.
		if(y != -1) break;
	}
	//기저 사례: 모든 칸을 채웠으면 1을 반환한다.
	if(y == -1) return 1;
	int ret = 0;
	//4가지 타입의 수만큼 반복.
	for(int type = 0; type < 4; ++type) {
		//만약 board[y][x]를 type 형태로 덮을 수 있으면 재귀 호출한다.
		if(set(board, y, x, type, 1)) {
			//경우의 수 합산.
			ret += cover(board);
		}
		//덮었던 블록을 치운다.
		set(board, y, x, type, -1);
	}
	//결과값 반환.
	return ret;
  }
}
테스트 케이스?(C<=30):1
H(1<=H):3
W(W<=20):7
#은 검은 칸, .는 흰 칸:#.....#
#은 검은 칸, .는 흰 칸:#.....#
#은 검은 칸, .는 흰 칸:##..###
결과 : 2