Solitaire

Solitaire

Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)

Total Submission(s): 190 Accepted Submission(s): 68

Problem Description

Solitaire is a game played on a chessboard 8x8. The rows and columns of the chessboard are numbered from 1 to 8, from the top to the bottom and from left to right respectively.

There are four identical pieces on the board. In one move it is allowed to:

> move a piece to an empty neighboring field (up, down, left or right),

> jump over one neighboring piece to an empty field (up, down, left or right).

There are 4 moves allowed for each piece in the configuration shown above. As an example let's consider a piece placed in the row 4, column 4. It can be moved one row up, two rows down, one column left or two columns right.

Write a program that:

> reads two chessboard configurations from the standard input,

> verifies whether the second one is reachable from the first one in at most 8 moves,

> writes the result to the standard output.

 

Input

Each of two input lines contains 8 integers a1, a2, ..., a8 separated by single spaces and describes one configuration of pieces on the chessboard. Integers a2j-1 and a2j (1 <= j <= 4) describe the position of one piece - the row number and the column number respectively. Process to the end of file.

 

Output

The output should contain one word for each test case - YES if a configuration described in the second input line is reachable from the configuration described in the first input line in at most 8 moves, or one word NO otherwise.

 

Sample Input

4 4 4 5 5 4 6 5
2 4 3 3 3 6 4 6

 

Sample Output

YES

 

Source

Southwestern Europe 2002

 

Recommend

Ignatius.L

 

/*
题意：给你四个棋子的坐标，让你判断八步内能不能走到指定位置

初步思路：bfs(),总共四个棋子，每个棋子都有最多四种走法，四个坐标是一种状态，vis八维记录四个棋子的状态

#超内存：什么鬼...找到了，可能是bfs()的时候，爆了

#改进：靠，手残了，判断是不是最后一步的时候，写残了，因为最后四个棋子并不是按照顺序到达四个位置的
*/
#include<bits/stdc++.h>
using namespace std;
struct node{
    int step;
    int x[],y[];
};//四个棋子的状态
node Start;//初状态
node last;//末状态
bool mapn[][];
bool vis[][][][][][][][];//用于记录四个棋子的八个坐标的状态
int dir[][]={,,-,,,,,-};//方向数组

bool Catch(node a){//判断是不是搜索到最后一步
    for(int i=;i<;i++){
        if(!mapn[a.x[i]][a.y[i]]) return false;
    }
    return true;
}
bool judge(node a,int k){//判断要去的那一步有没有棋子
    for(int i=;i<;i++){
        if(i!=k&&a.x[i]==a.x[k]&&a.y[i]==a.y[k]) return true;
    }
    return false;
}
bool ok(node a){//判断坐标是否合法
    for(int i=;i<;i++){
        if(a.x[i]<||a.x[i]>=||a.y[i]<||a.y[i]>=) return false;
    }
    if(vis[a.x[]][a.y[]][a.x[]][a.y[]]
            [a.x[]][a.y[]][a.x[]][a.y[]]==true) return false;
    return true;
}
bool bfs(){
    queue<node>q;
    node Next;

    vis[Start.x[]][Start.y[]][Start.x[]][Start.y[]]
        [Start.x[]][Start.y[]][Start.x[]][Start.y[]]=true;

    Start.step=;

    q.push(Start);
    while(!q.empty()){
        Start=q.front();
        q.pop();
        // for(int i=0;i<4;i++){
            // cout<<Start.x[i]+1<<" "<<Start.y[i]+1<<" ";
        // }
        // cout<<endl;
        if(Start.step>=) return false;
        for(int i=;i<;i++){//遍历四个棋子
            for(int j=;j<;j++){//遍历四个方向

                Next=Start;
                Next.x[i]+=dir[j][];
                Next.y[i]+=dir[j][];//走向下一步
                Next.step++;
                if(ok(Next)==false) continue;//下一步违法的

                //cout<<"ok"<<endl;

                if(judge(Next,i)==true){//下一步有棋子了
                    Next.x[i]+=dir[j][];
                    Next.y[i]+=dir[j][];//再走一步

                    if(ok(Next)==false||judge(Next,i)==true) continue;//下一步违法的或者下一步还是有棋子

                    else{
                        if(Catch(Next)==true){
                            // cout<<q.size()<<endl;
                            return true;
                        }
                        vis[Next.x[]][Next.y[]][Next.x[]][Next.y[]]
                            [Next.x[]][Next.y[]][Next.x[]][Next.y[]]=true;

                        q.push(Next);//放进队列中
                    }
                }else{
                    if(Catch(Next)==true){
                        // cout<<q.size()<<endl;
                        return true;
                    }
                    vis[Next.x[]][Next.y[]][Next.x[]][Next.y[]]
                        [Next.x[]][Next.y[]][Next.x[]][Next.y[]]=true;

                    q.push(Next);//放进队列中
                }
            }
        }
    }
    return false;
}
void init(){
    memset(vis,false,sizeof vis);
    memset(mapn,false,sizeof mapn);
}
int main(){
    // freopen("in.txt","r",stdin);
    while(scanf("%d%d",&Start.x[],&Start.y[])!=EOF){
        init();
        Start.x[]--;
        Start.y[]--;
        for(int i=;i<;i++){
            scanf("%d%d",&Start.x[i],&Start.y[i]);
            Start.x[i]--;
            Start.y[i]--;
        }
        //标记初状态

        for(int i=;i<;i++){
            scanf("%d%d",&last.x[i],&last.y[i]);
            last.x[i]--;
            last.y[i]--;
            mapn[last.x[i]][last.y[i]]=true;
        }

        // for(int i=0;i<4;i++){
            // cout<<last.x[i]+1<<" "<<last.y[i]+1<<" ";
        // }
        // cout<<endl;

        bool flag=bfs();
        printf(flag==true?"YES\n":"NO\n");
    }
    return ;
}