Problem:
Problem D: Dice Room

You are playing a popular video game which is famous for its depthful story and interesting
puzzles. In the game you were locked in a mysterious house alone and there is no way to call for
help, so you have to escape on yours own. However, almost every room in the house has some
kind of puzzles and you cannot move to neighboring room without solving them.

One of the puzzles you encountered in the house is following. In a room, there was a device
which looked just like a dice and laid on a table in the center of the room. Direction was written
on the wall. It read:

"This cube is a remote controller and you can manipulate a remote room, Dice
Room, by it. The room has also a cubic shape whose surfaces are made up of 3x3
unit squares and some squares have a hole on them large enough for you to go though
it. You can rotate this cube so that in the middle of rotation at least one edge always
touch the table, that is, to 4 directions. Rotating this cube affects the remote room
in the same way and positions of holes on the room change. To get through the
room, you should have holes on at least one of lower three squares on the front and
back side of the room."

You can see current positions of holes by a monitor. Before going to Dice Room, you should
rotate the cube so that you can go though the room. But you know rotating a room takes some
time and you don’t have much time, so you should minimize the number of rotation. How many
rotations do you need to make it possible to get though Dice Room?

Input

The input consists of several datasets. Each dataset contains 6 tables of 3x3 characters which
describe the initial position of holes on each side. Each character is either '*' or '.'. A hole is
indicated by '*'. The order which six sides appears in is: front, right, back, left, top, bottom.
The order and orientation of them are described by this development view:

Figure 4: Dice Room

Figure 5: available dice rotations

There is a blank line after each dataset. The end of the input is indicated by a single '#'.

Output

Print the minimum number of rotations needed in a line for each dataset. You may assume all
datasets have a solution.

Sample Input

...
...
.*.
...
...
.*.
...
...
...
...
...
.*.
...
...
.*.
...
...
...

...
.*.
...
*..
...
..*
*.*
*.*
*.*
*.*
.*.
*.*
*..
.*.
..*
*.*
...
*.*

...
.*.
.*.
...
.**
*..
...
...
.*.
.*.
...
*..
..*
...
.**
...
*..
...

#

Output for the Sample Input

3
1
0

Solution in JAVA (judge verdict: Wrong Answer)


import java.util.*;
import java.lang.*;
import java.math.*;

public class Main {
	Scanner sc = new Scanner(System.in);

	void run() {
		for (;;) {
			String f = sc.next();
			if (f.equals("#")) {
				break;
			}

			char[][][] dice = new char[6][3][];
			dice[0][0] = f.toCharArray();
			dice[0][1] = sc.next().toCharArray();
			dice[0][2] = sc.next().toCharArray();

			int[] z = { 0, 1, 3, 4, 2, 5 };

			for (int i = 0; i < 6; i++) {
				// z[zinv[i]]= i;
			}
			for (int i = 1; i < 6; i++) {
				for (int j = 0; j < 3; j++) {
					if (z[i] == 5) {
						dice[z[i]][2 - j] = sc.next().toCharArray();
					} else if (i == 2 || i == 3) {
						char temp;
						dice[z[i]][j] = sc.next().toCharArray();
						temp = dice[z[i]][j][0];
						dice[z[i]][j][0] = dice[z[i]][j][2];
						dice[z[i]][j][2] = temp;
					} else {
						dice[z[i]][j] = sc.next().toCharArray();
					}
				}
			}

			boolean ok[][] = new boolean[3][4];

			for (int i = 0; i < 3; i++) {
				ok[i][0] = false;
				for (int j = 0; j < 3; j++) {
					if (dice[i + 3][0][j] == '*') {
						ok[i][0] = true;
					}
				}
				//
				for (int j = 0; j < 3; j++) {
					if (dice[i][2][j] == '*') {
						if (dice[i + 3][2][j] == '*') {
							// System.out.println((i+3)+" "+j);
							ok[i][3] = true;
						}
					}
				}
				//
				for (int j = 0; j < 3; j++) {
					if (dice[i][j][0] == '*') {
						if (dice[i + 3][j][0] == '*') {
							ok[i][1] = true;
						}
					}
				}
				//
				for (int j = 0; j < 3; j++) {
					if (dice[i][j][2] == '*') {
						if (dice[i + 3][j][2] == '*') {
							ok[i][2] = true;
						}
					}
				}
			}

			int ans[][] = { { 2, 1, 1, 0 }, { 3, 2, 2, 3 }, { 1, 2, 2, 1 } };
			int min = Integer.MAX_VALUE;
			for (int i = 0; i < 3; i++) {
				for (int j = 0; j < 4; j++) {
					if (ok[i][j]) {
						// System.out.println(i+" "+j);
						min = Math.min(ans[i][j], min);
					}
				}
			}
			System.out.println(min);
		}

	}

	public static void main(String[] args) {
		Main m = new Main();
		m.run();
	}
}