Problem:
Problem B: Cleaning Robot

Dr. Asimov, a robotics researcher, loves to research, but hates houseworks and his house were really dirty. So, he has developed a cleaning robot.

As shown in the following figure, his house has 9 rooms, where each room is identified by an alphabet:

The robot he developed operates as follows:

If the battery runs down, the robot stops.

If not so, the robot chooses a direction from four cardinal points with the equal probability, and moves to the room in that direction. Then, the robot clean the room and consumes 1 point of the battery.

However, if there is no room in that direction, the robot does not move and remains the same room. In addition, there is a junk room in the house where the robot can not enter, and the robot also remains when it tries to enter the junk room. The robot also consumes 1 point of the battery when it remains the same place.

A battery charger for the robot is in a room. It would be convenient for Dr. Asimov if the robot stops at the battery room when its battery run down.

Your task is to write a program which computes the probability of the robot stopping at the battery room.

Input

The input consists of several datasets. Each dataset consists of:

n
s t b

n is an integer that indicates the initial battery point. s, t, b are alphabets respectively represent the room where the robot is initially, the battery room, and the junk room.

The input ends with a dataset which consists of single 0 for n. Your program should not output for this dataset.

Output

For each dataset, print the probability as a floating point number in a line. The answer may not have an error greater than 0.000001.

Constraints

Judge data includes at most 100 data sets.

n ≤ 15

s, t, b are distinct.

Sample Input

1
E A C
1
E B C
2
E A B
0

Output for the Sample Input

0.00000000
0.25000000
0.06250000

Solution in JAVA (judge verdict: Accepted)


import java.io.*;

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

import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
import static java.math.BigInteger.*;
import static java.lang.Character.*;

class AOJ1020 {
	int[] di = { +1, -1, +3, -3 };

	public void run() {
		Scanner sc = new Scanner(System.in);
		while (true) {
			int n = sc.nextInt();
			if (n == 0)
				return;
			int s = sc.next().charAt(0) - 'A';
			int t = sc.next().charAt(0) - 'A';
			int b = sc.next().charAt(0) - 'A';

			double[] prob = new double[9];
			double[][] move = new double[9][9];
			for (int i = 0; i < 9; i++)
				for (int d = 0; d < 4; d++) {
					int j = (!isValidMove(i, d) || i + di[d] == b) ? i : i + di[d];
					move[j][i] += .25;
				}

			prob[s] = 1.;
			for (int k = 0; k < n; k++) {
				double[] np = new double[9];
				for (int i = 0; i < 9; i++)
					for (int j = 0; j < 9; j++)
						np[i] += move[i][j] * prob[j];
				prob = np;
			}
			System.out.println(prob[t]);
		}
	}

	boolean isValidMove(int i, int d) {
		switch (d) {
		case 0:
			return i % 3 < 2;
		case 1:
			return i % 3 > 0;
		case 2:
			return i < 6;
		case 3:
			return i > 2;
		}
		return false;
	}
}

public class Main {
	public static void main(String... args) {
		new AOJ1020().run();
	}

	public static void debug(Object... os) {
		System.err.println(java.util.Arrays.deepToString(os));
	}
}

class Scanner {
	final java.util.Scanner sc;

	public double nextDouble() {
		return Double.parseDouble(sc.next());
	}

	public Scanner(java.io.InputStream is) {
		this.sc = new java.util.Scanner(is);
	}

	public boolean hasNext() {
		return sc.hasNext();
	}

	public String next() {
		return sc.next();
	}

	public int nextInt() {
		return Integer.parseInt(sc.next());
	}

	public String nextLine() {
		return sc.nextLine();
	}

	public long nextLong() {
		return Long.parseLong(sc.next());
	}
}