The Rotation Game

Description

The rotation game uses a # shaped board, which can hold 24 pieces of square blocks (see Fig.1). The blocks are marked with symbols 1, 2 and 3, with exactly 8 pieces of each kind.

Initially, the blocks are placed on the board randomly. Your task is to move the blocks so that the eight blocks placed in the center square have the same symbol marked. There is only one type of valid move, which is to rotate one of the four lines, each consisting of seven blocks. That is, six blocks in the line are moved towards the head by one block and the head block is moved to the end of the line. The eight possible moves are marked with capital letters A to H. Figure 1 illustrates two consecutive moves, move A and move C from some initial configuration.

Input

The input consists of no more than 30 test cases. Each test case has only one line that contains 24 numbers, which are the symbols of the blocks in the initial configuration. The rows of blocks are listed from top to bottom. For each row the blocks are listed from left to right. The numbers are separated by spaces. For example, the first test case in the sample input corresponds to the initial configuration in Fig.1. There are no blank lines between cases. There is a line containing a single `0' after the last test case that ends the input.

Output

For each test case, you must output two lines. The first line contains all the moves needed to reach the final configuration. Each move is a letter, ranging from `A' to `H', and there should not be any spaces between the letters in the line. If no moves are needed, output `No moves needed' instead. In the second line, you must output the symbol of the blocks in the center square after these moves. If there are several possible solutions, you must output the one that uses the least number of moves. If there is still more than one possible solution, you must output the solution that is smallest in dictionary order for the letters of the moves. There is no need to output blank lines between cases.

Sample Input

1 1 1 1 3 2 3 2 3 1 3 2 2 3 1 2 2 2 3 1 2 1 3 3

1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3

0

Sample Output

AC

2

DDHH

2

Source

Shanghai 2004

圖中的#字格的4條豎線，可以按8個方向倒轉里面的數字方塊，當中間的8個數字方塊是同一個數字時，游戲結束。這道題就要求搜索一個最短路徑，倒轉8個方向使得中間8個數字相等。這道題目看起來很像一道單純的BFS，看了POJ里面說BFS會爆內存，我沒試，估計寫得好的也爆不了。但是估計寫BFS還要涉及到狀態的判重，程序寫起來也不方便。我用了迭代加深的搜索方法。第一次接觸這個算法，我說一下我的理解：

       原來我很不理解迭代加深，搜索的深度一層一層地加，在后面的某一深度限制下搜索，必定會搜到前面深度所能搜到的結果，這會造成重復搜索。基于這點，我一直都認為迭代加深搜索的方法很冗余，當然也是自己從來都沒有動手試過。像這道題就給我的收獲不少，有的時候選擇一定的策略進行搜索，我們是很難確定解所在狀態空間的深度的，有時可能解的深度不大，但整個狀態空間的深度很大，盲目的dfs搜索在狀態空間里就有可能會越陷越深，遲遲出不了解，同時整個狀態空間的寬度也很大，用BFS可能就會爆空間。迭代加深搜索恰恰是取了一個折中。利用了dfs的優勢，限制了搜索的深度，避免了出現無解的境地。由于深度是逐個增加的，當搜到一個解后就退出，所以避免了BFS中判重的一步操作，當然在迭代深搜的過程中，還可以加入剪枝，可以優化程序。但是我的程序在POJ上還不快，還要找找原因，也許還有優化。下面是一些關鍵代碼：

for(limit=0; ;limit++)
        {
            if(dfs(start,0))
            {
                if(limit == 0)
                {
                    printf("No moves needed\n");
                }
                else
                {
                    for(i=0; i<limit; i++)
                    {
                        printf("%c",'A'+pre[i]);
                    }
                    printf("\n");
                }
                printf("%d\n",rlt);
                break;
            }
        }
///迭代過程
int dfs(struct S now, int depth)
{
    int c1,c2,c3;
    struct S st;
    test(now,c1,c2,c3);
    if(c1 == 8)
    {
        rlt=1;
        return 1;
    }
    else if(c2 == 8)
    {
        rlt=2;
        return 1;
    }
    else if(c3 == 8)
    {
        rlt=3;
        return 1;
    }
    if(depth == limit)
        return 0;
    if(8-c1 > limit-depth && 8-c2 > limit-depth && 8-c3 > limit-depth)
        return 0;
    st=NewStateA(now);
    pre[depth]=0;
    if(dfs(st,depth+1))
        return 1;
    st=NewStateB(now);
    pre[depth]=1;
    if(dfs(st,depth+1))
        return 1;
    st=NewStateC(now);
    pre[depth]=2;
    if(dfs(st,depth+1))
        return 1;
    st=NewStateD(now);
    pre[depth]=3;
    if(dfs(st,depth+1))
        return 1;
    st=NewStateE(now);
    pre[depth]=4;
    if(dfs(st,depth+1))
        return 1;
    st=NewStateF(now);
    pre[depth]=5;
    if(dfs(st,depth+1))
        return 1;
    st=NewStateG(now);
    pre[depth]=6;
    if(dfs(st,depth+1))
        return 1;
    st=NewStateH(now);
    pre[depth]=7;
    if(dfs(st,depth+1))
        return 1;
    return 0;
}
///深搜