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 Kotlin (judge verdict: Wrong Answer)


fun main(args:Array<String>):Unit {
    val charToPoint = mapOf(Pair("A", Point(0, 0)), Pair("B", Point(1, 0)), Pair("C", Point(2, 0)),
            Pair("D", Point(0, 1)), Pair("E", Point(1, 1)), Pair("F", Point(2, 1)),
            Pair("G", Point(0, 2)), Pair("H", Point(1, 2)), Pair("I", Point(2, 2))
            )
    val points = (0 until 3).flatMap{y -> (0 until 3).map{Point(it, y)}}
    while(true){
        val n = readLine()!!.trim().toInt()
        if (n == 0) return
        val roomState = Array(3){Array(3){true}}
        val (s, t, b) = readLine()!!.trim().split(' ')
        val start = charToPoint[s]!!
        val buttery = charToPoint[t]!!
        roomState[charToPoint[b]!!.y][charToPoint[b]!!.x] = false
        val matrix = Array(9){Array(9){.0}}
        points.forEachIndexed { index, point ->
            point.neighbors().forEach {
                if (it.x in 0 until 3 && it.y in 0 until 3 && roomState[it.y][it.x]){
                    matrix[index][it.x + it.y * 3] += 0.25
                }else{
                    matrix[index][point.x + point.y * 3] += 0.25
                }
            }
        }
        val res = exp(matrix, n)
        println(res[buttery.x + buttery.y * 2][start.x + start.y * 3])
    }
}
operator fun Array<Array<Double>>.times(that:Array<Array<Double>>):Array<Array<Double>> {
    return this.map{line ->
        that.first().indices.map{column ->
            line.zip(that.map{it[column]}).sumByDouble{(a, b) -> a * b}
        }.toTypedArray()
    }.toTypedArray()
}
fun exp(base:Array<Array<Double>>, e:Int):Array<Array<Double>> {
    return when(e){
        0 -> Array(base.size){y -> Array(base.size){x -> if (x == y) 1.0 else .0}}
        1 -> base
        else -> exp(base, e / 2).let{if (e % 2 == 1) base * it * it else it * it}
    }
}
data class Point(val x:Int, val y:Int){
    operator fun plus(that:Point):Point = Point(x + that.x, y + that.y)
    fun neighbors():Iterable<Point> = listOf(Point(1, 0), Point(-1, 0), Point(0, 1), Point(0, -1)).map{this + it}
}