poj1198

poj1198:

 

Solitaire

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. 

用广度优先搜索求最小路径（其实原题给定了最大步数，深搜搜到第八步跳出循环也可以解决，但是容易超时）。

根据广度优先搜索的几个基本步骤，在写题之前先把思路整理好：

1. 每个结点的棋盘都将只有四个点是棋子，也就是说，与其用8x8 的数组存储，不如只存坐标。
2. 每个父结点的每个棋子都有4种走法，四个棋子有16种走法。如果搜到8步，那将是16⁸，也就是2³²=429496729，数组开不下，并且必定会超时。

解决的办法有两个：

1. 判重并且使用到哈希解码，对于冲突，我们可以用字符串记录路径，发生冲突时叠加字符串即可。对于判重，从头到尾的比较肯定会超时，我们可以开一个86878889长度的数组（可能出现的最大项，可以用平移优化），用来打标记判重。
2. 我们可以写一个双向BFS（个人更喜欢这种做法），双向搜索只需要搜4层就够了。

值得注意的是，如果开数组打标记的方法判重，一定要把每个结点的四个坐标都排好序！

以下是代码：

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

//定义棋子 
struct point{
    int x, y;
};
//定义初始、目标棋盘 
point a[5], b[5];
int numa, numb;
//输出棋盘 
void print(point a[5]){
    
    for (int i=1; i<=4; ++i) printf("%d%d", a[i].x, a[i].y);
    printf("
");
    
}

//将棋盘转换为十进制数 
int f(point a[5]){
    int s=0;
    for (int i=1; i<=4; ++i) s=s*100+a[i].x*10+a[i].y;
    return s;
} 
bool cmp(point a, point b){
    return a.x<b.x or (a.x==b.x and a.y<b.y);
}

//偏移量
point d[5]={{ 0, 0},
            {+1, 0},
            {-1, 0},
            { 0,+1},
            { 0,-1}};
        
//定义判重的数组 flag
bool flag[85868789];
//定义节点
struct node{
    point a[5];
    int dep;
    int fa;
}; 
node data[6000000]; 
//判断x,y位置是否出界 
bool check(int x, int y){
    return (x>=1 and x<=8 and y>=1 and y<=8);
}
//检查a棋盘的x,y位置是否有棋子 有返回真 
bool check1(point a[5], int x, int y){
    for (int i=1; i<=4; ++i)
        if (a[i].x==x and a[i].y==y) return true;
    return false;
}
//复制棋盘 
void copy1(point a[5], point b[5]){
    for (int i=1; i<=4; ++i) b[i].x=a[i].x,b[i].y=a[i].y;
}
int op , cl;
void print1(int cl){
    
    int ans[10], n=0;
    while (cl!=-1){
        ans[++n]=cl;
        cl=data[cl].fa;
    }
    printf("

");
    for (int i=n; i>1; --i) print(data[ans[i]].a);
    print(data[ans[1]].a);
}
int main(){
    //freopen("poj1198.in", "r", stdin);
    for (int i=1; i<=4; ++i) scanf("%d%d", &a[i].x, &a[i].y);   
    for (int i=1; i<=4; ++i) scanf("%d%d", &b[i].x, &b[i].y);
    //print(a);
    //print(b);
    sort(a+1, a+5, cmp);
    sort(b+1, b+5, cmp);
    numa=f(a);
    numb=f(b);
    //print(a);
    //print(b);
    //printf("%d %d
", numa, numb); 
    //特判初始状态和目标状态
    if (numa==numb){
        
        printf("YES");
        return 0;
        
    } 
    //初始化 首节点入队 首尾设置指针 
    copy1(a, data[1].a); data[1].dep=0; data[1].fa=-1;
    //memset(flag, false, sizeof flag);
    flag[numa]=true;
    
    op = 0, cl = 1;
    bool f1=false;
    while (op<cl and !f1 and data[op+1].dep<8){
        ++op;
        
        int dep=data[op].dep;
        
        for (int i=1; i<=4; ++i){
            
            for (int j=1; j<=4; ++j){
                
                copy1(data[op].a, a);  //每个操作要从原始棋盘开始
                
                //x1,y1移动一步的位置
                //x2,y2跳跃一步的位置 
                int x1=a[i].x+d[j].x, y1=a[i].y+d[j].y;
                int x2=x1+d[j].x, y2=y1+d[j].y;
                
                if (check(x1, y1) and !check1(a, x1, y1)) {//x1,y1位置不出界且x1,y1位置无棋子 
                    
                    a[i].x=x1; a[i].y=y1;   //移动到新位置
                    sort(a+1, a+5, cmp);    //排序
                    numa=f(a);              //转化为数
                    if (!flag[numa]){       //判重
                        flag[numa]=true;    //标记 
                        
                        ++cl;               //入队 
                        copy1(a, data[cl].a);
                        data[cl].dep=dep+1;
                        data[cl].fa=op;
                        
                        //判断目标
                        if (numa==numb){
                            f1=true;
                            break;
                        }
                    }   
                }else
                if (check(x1, y1) and check(x2, y2) and 
                    check1(a, x1, y1) and !check1(a, x2, y2)) {
                    //x1,y1,x2,y2位置不出界且x1,y1位置有棋子,x2,y2位置无棋子
                    
                    a[i].x=x2; a[i].y=y2;   //跳跃到新位置 
                    sort(a+1, a+5, cmp);    //排序 
                    numa=f(a);              //转化为数 
                    if (!flag[numa]){       //判重 
                        flag[numa]=true;    //标记 
                        
                        ++cl;               //入队 
                        copy1(a, data[cl].a);
                        data[cl].dep=dep+1;
                        data[cl].fa=op;
                        
                        //判断目标 
                        if (numa==numb){
                            f1=true;
                            break;
                        }
                    }   
                }
            }
            if (f1) break;
        }
    }
    if (f1) printf("YES
"); else printf("NO
");
    return 0;
}