pku2286 The Rotation Game

有点像模拟的IDA*，做了才发现和大多数人的思路一样

题意：定义chessboard上的8个移位操作：处于操作端的元素放到所在列（行）的最尾，该列（行）的所有元素向操作端方向移动一格。求最短的操作序列使得中间8个形成正方形的元素相等。

Memory: 208K   Time: 266MS

    #include <iostream>
    using namespace std;

    int a1[200],a2[200],a3[200],a4[200],beg1,beg2,beg3,beg4,array[25],deep,cnt[4];
    char path[50];

    void shift(int n,bool left){
        switch(n){
        case 1:
            if(left){
                a1[beg1+7]=a1[beg1];

                a3[beg3+2]=a1[beg1+3];
                a4[beg4+2]=a1[beg1+5];
                beg1++;
            }
            else{
                a1[beg1-1]=a1[beg1+6];
                
                a3[beg3+2]=a1[beg1+1];
                a4[beg4+2]=a1[beg1+3];
                beg1--;
            }
            break;
        case 2:
            if(left){
                a2[beg2+7]=a2[beg2];
                
                a3[beg3+4]=a2[beg2+3];
                a4[beg4+4]=a2[beg2+5];
                beg2++;
            }
            else{
                
                a2[beg2-1]=a2[beg2+6];
                
                a3[beg3+4]=a2[beg2+1];
                a4[beg4+4]=a2[beg2+3];
                beg2--;
            }
            break;
        case 3:
            if(left){
                a3[beg3+7]=a3[beg3];
                
                a1[beg1+2]=a3[beg3+3];
                a2[beg2+2]=a3[beg3+5];
                beg3++;
            }
            else{
                a3[beg3-1]=a3[beg3+6];

                a1[beg1+2]=a3[beg3+1];
                a2[beg2+2]=a3[beg3+3];
                beg3--;
            }
            break;
        case 4:
            if(left){
                a4[beg4+7]=a4[beg4];
                
                a1[beg1+4]=a4[beg4+3];
                a2[beg2+4]=a4[beg4+5];
                beg4++;
            }
            else{
                a4[beg4-1]=a4[beg4+6];
                
                a1[beg1+4]=a4[beg4+1];
                a2[beg2+4]=a4[beg4+3];
                beg4--;
            }
            break;
        }
    }

    int f(){
        int i,mx=0;
        cnt[1]=cnt[2]=cnt[3]=0;

        cnt[array[a1[beg1+2]]]++;
        cnt[array[a1[beg1+4]]]++;
        cnt[array[a2[beg2+4]]]++;
        cnt[array[a2[beg2+2]]]++;
        cnt[array[a3[beg3+3]]]++;
        cnt[array[a1[beg1+3]]]++;
        cnt[array[a4[beg4+3]]]++;
        cnt[array[a2[beg2+3]]]++;

        for(i=1;i<=3;i++)
            if(cnt[i]>mx)
                mx=cnt[i];
        return 8-mx;
    }

        



    void init(){
        beg1=beg2=beg3=beg4=100;
        a1[100]=1;
        a1[101]=3;
        a1[102]=7;
        a1[103]=12;
        a1[104]=16;
        a1[105]=21;
        a1[106]=23;

        a2[100]=2;
        a2[101]=4;
        a2[102]=9;
        a2[103]=13;
        a2[104]=18;
        a2[105]=22;
        a2[106]=24;

        a3[100]=5;
        a3[101]=6;
        a3[102]=7;
        a3[103]=8;
        a3[104]=9;
        a3[105]=10;
        a3[106]=11;

        a4[100]=14;
        a4[101]=15;
        a4[102]=16;
        a4[103]=17;
        a4[104]=18;
        a4[105]=19;
        a4[106]=20;
        /*
                     a1:   a2:
                     1     2
                     3     4
        a3: 5  6  7  8  9  10 11
                     12    13
        a4: 14 15 16 17 18 19 20
                     21    22
                     23    24
        */
    }

    bool idfs(int d){
        if(d==deep){
            if(array[a1[beg1+2]]==array[a1[beg1+4]] 
                && array[a1[beg1+2]]==array[a2[beg2+4]] 
                && array[a1[beg1+2]]==array[a2[beg2+2]]
                && array[a1[beg1+2]]==array[a3[beg3+3]]
                && array[a1[beg1+2]]==array[a1[beg1+3]]
                && array[a1[beg1+2]]==array[a4[beg4+3]]
                && array[a1[beg1+2]]==array[a2[beg2+3]])
                return true;
            else
                return false;
        }

        if(d+f()>deep)
            return false;

        shift(1,true);
        path[d]='A';
        if(idfs(d+1))
            return true;
        shift(1,false);
        
        shift(2,true);
        path[d]='B';
        if(idfs(d+1))
            return true;
        shift(2,false);

        shift(3,false);
        path[d]='C';
        if(idfs(d+1))
            return true;
        shift(3,true);

        shift(4,false);
        path[d]='D';
        if(idfs(d+1))
            return true;
        shift(4,true);

        shift(2,false);
        path[d]='E';
        if(idfs(d+1))
            return true;
        shift(2,true);

        shift(1,false);
        path[d]='F';
        if(idfs(d+1))
            return true;
        shift(1,true);
        
        shift(4,true);
        path[d]='G';
        if(idfs(d+1))
            return true;
        shift(4,false);

        shift(3,true);
        path[d]='H';
        if(idfs(d+1))
            return true;
        shift(3,false);

        return false;
    }


        

    int main(){
        int i;
        while(scanf("%d",&array[1]) && array[1]){
            for(i=2;i<=24;i++)
                scanf("%d",&array[i]);
            for(deep=0;deep<100;deep++){
                init();
                if(idfs(0))
                    break;
            }
            if(deep==0)
                printf("No moves needed\n%d\n",array[a1[beg1+2]]);
            else{
                for(i=0;i<deep;i++)
                    printf("%c",path[i]);
                printf("\n%d\n",array[a1[beg1+2]]);
            }
        }
        return 0;
    }