1455.Solitaire（bfs状态混摇）

Solitaire

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 3570    Accepted Submission(s): 1098

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

 #include<stdio.h>
 #include<queue>
 #include<string.h>
 #include<math.h>
 #include<algorithm>
 typedef long long ll ;
 bool vis[][][][][][][][] ;
 int move[][] = {{,} , {-,} , {,} , {,-}} ;
 struct no
 {
     int x , y ;
 } ee[] ;

 bool cmp (const no a , const no b)
 {
     if (a.x < b.x) {
         return true ;
     }
     else if (a.x == b.x) {
         if (a.y < b.y) return true ;
         else return false ;
     }
     else return false ;
 }

 struct node
 {
     int a[][] ;
     int step ;
 };
 node st , end ;

 bool bfs ()
 {
     node ans , tmp ;
     no rr[] ;
     std::queue <node> q ;
     while ( !q.empty ()) q.pop () ;
     st.step =  ;
     q.push (st) ;
     while ( !q.empty ()) {
         ans = q.front () ; q.pop () ;
         for (int i =  ; i <  ; i ++) {
             for (int j =  ; j <  ; j ++) {
                 tmp = ans ;
                 int x = tmp.a[i][] + move[j][] , y = tmp.a[i][] + move[j][] ;
                 if (x <  || y <  || x >=  || y >= ) continue ;
                 bool flag =  ;
                 for (int i =  ; i <  ; i ++ ) {
                     if (x == tmp.a[i][] && y == tmp.a[i][])
                         flag =  ;
                 }
                 if (flag ) {
                     x += move[j][] , y += move[j][] ;
                     if (x <  || y <  || x >=  || y >= ) continue ;
                     for (int i =  ; i <  ; i ++) {
                         if (x == tmp.a[i][] && y == tmp.a[i][])
                             flag =  ;
                     }
                     if ( !flag ) continue ;
                 }
                 tmp.step ++ ;
                 if (tmp.step > ) continue ;
                 tmp.a[i][] = x , tmp.a[i][] = y ;
                 if ( vis[tmp.a[][]] [tmp.a[][]] [tmp.a[][]] [tmp.a[][]] [tmp.a[][]] [tmp.a[][]] [tmp.a[][]] [tmp.a[][]]) continue;
                 vis[tmp.a[][]] [tmp.a[][]] [tmp.a[][]] [tmp.a[][]] [tmp.a[][]] [tmp.a[][]] [tmp.a[][]] [tmp.a[][]] =  ;
                 int cnt =  ;
                 for (int i =  ; i <  ; i ++) {
                     rr[i].x = tmp.a[i][] ; rr[i].y = tmp.a[i][] ;
                 }
                 std::sort (rr , rr +  , cmp ) ;
               /*  for (int i = 0 ; i < 4 ; i ++) {
                     printf ("(%d , %d) , " , rr[i].x , rr[i].y ) ;
                 } puts ("") ; */
                 for (int i =  ; i <  ; i ++) {
                     if (rr[i].x != ee[i].x || rr[i].y != ee[i].y )
                         cnt ++ ;
                 }
                 if ( ! cnt ) return true ;
                 if (tmp.step + cnt > ) continue ;
                 q.push (tmp) ;
                // printf ("step = %d\n" , tmp.step ) ;
             }
         }
     }
     return false ;
 }

 int main ()
 {
     //freopen ("a.txt" , "r" , stdin ) ;
     while ( ~ scanf ("%d%d" , &st.a[][] , &st.a[][])) {
         st.a[][] -- ; st.a[][] -- ;
         memset (vis ,  , sizeof(vis)) ;
         for (int i =  ; i <  ; i ++) for (int j =  ; j <  ; j ++) { scanf ("%d" , &st.a[i][j]) ; st.a[i][j] -- ;}
         for (int i =  ; i <  ; i ++) for (int j =  ; j <  ; j ++) { scanf ("%d" , &end.a[i][j]) ; end.a[i][j] -- ;}
         for (int i =  ; i <  ; i ++) {
             ee[i].x = end.a[i][] , ee[i].y = end.a[i][] ;
         }
     // std::sort (ss , ss + 4 , cmp ) ;
         std::sort (ee , ee +  , cmp ) ;
         if ( bfs ()) puts ("YES") ;
         else puts ("NO") ;
     }
     return  ;
 }

四枚棋子彼此不可分，所以对每次个状态因进行一下操作，比如说排序。