HDU 1401 Solitaire

题意：

在一个8×8的棋盘中，给定你4个棋子A，再给你4个棋子B，问你在8步之内能不能够从A位置移动到B位置；

规则：棋子能能上下左右移动，同时能跳过相邻的棋子到达相邻棋子的空地方；

 

这个题要用双向搜索；同时我用一个8维的数组hash来构造一个图；当hash标记为1时表示A到过该点，标记为2时表示B到过该点；

这里要注意就是A,B同时搜索时他们分别最多只能走4步，如果多于4步，那么他们步数之和就可能大于8；

这里还要用到排序，这个很重要，因为4个点是不分形状大小的，那么我们就不会重复走；

View Code

#include<iostream>
#include<queue>
#include<algorithm>
using namespace std;
class Node
{
public:
int x,y;
};
class T
{
public:
   Node node[4];
int step;    
};
queue<T>q1;
queue<T>q2;
const int d[4][2] = { 0,1,1,0,-1,0,0,-1 };
char hash[8][8][8][8][8][8][8][8];
//构造一个4给点组成的图，1代表由A开始走过的点；2代表由B开始走过的点 
bool cmp( Node a, Node b )
{
if( a.x == b.x )
return a.y < b.y;
return a.x < b.x;    
}
char getnum( T t  )//得到标记的值 
{
return hash[t.node[0].x][t.node[0].y][t.node[1].x][t.node[1].y]
            [t.node[2].x][t.node[2].y][t.node[3].x][t.node[3].y];    
}
void setnum( T t , char value ) //给标记赋值 
{
    hash[t.node[0].x][t.node[0].y][t.node[1].x][t.node[1].y]
    [t.node[2].x][t.node[2].y][t.node[3].x][t.node[3].y] = value;    
}
bool judge( T &t , int i , int j , int m )//判断是否可以走 
{
if( m==1 )
   {
if( t.step >=4 )//最多移动4步 
           return false;
       t.step ++;    
   }
   t.node[i].x += d[j][0];
   t.node[i].y += d[j][1];
if( t.node[i].x >= 0 && t.node[i].x < 8 && t.node[i].y >=0 && t.node[i].y<8 )
   {   int k;
for(  k = 0 ; k< 4 ; k++ )
       {
if( i!=k )
           {
if( t.node[i].x==t.node[k].x&&t.node[i].y==t.node[k].y )//判断是否有点    
               if( m == 1 ) return judge( t , i , j , 2 );//判断是否跳过相邻的点可以合法走动 
               else return false;    
           }    
       }
if( k>=4 )
       { 
         sort( t.node , t.node + 4 , cmp );
return true;
       } 
    } 
return false;
}
bool BFS(  )
{
   T s;
while( !q1.empty()||!q2.empty() )//双向搜索 
   {
if( !q1.empty( ) ) 
       { 
for( int i = 0 ; i< 4 ;i++ )
for( int j = 0 ; j< 4 ; j++ )
              {    s = q1.front();
if( judge( s , i , j ,1 ) )//判断是否可以移动 
                   {
char c = getnum( s );
if( c  == 2 )//如果B已经到了这个点就表示可以从A移动到B 
                          return true;
else  if( c == 0 )//如果该点没有标记 
                         {
                              setnum( s , 1 );
                              q1.push( s );
                         } 
                   }        
              }
              q1.pop();        
       }   
if( !q2.empty( ) )
       {    
for( int i = 0 ; i< 4 ;i++ )
for( int j = 0 ; j< 4 ; j++ )
              {  s = q2.front();
if( judge( s , i , j ,1 ) )
                   {
char c = getnum( s );
if( c  == 1 )
return true;
else  if( c == 0 )
                         {
                              setnum( s , 2 );
                              q2.push( s );
                         } 
                   }        
              }
              q2.pop();        
       }         
   }
return false;    
}
int main( )
{
    T A,B;
int x ,y;
while( scanf( "%d%d",&x,&y )==2 )
    {
        memset( hash, 0 , sizeof( hash ) );
while( !q1.empty() )
              q1.pop();
while( !q2.empty() )
               q2.pop();
        A.node[0].x = --x;
        A.node[0].y = --y;
for( int i = 1; i< 4 ;i++ )
        {
           scanf( "%d%d",&x , &y );
           A.node[i].x = --x;
           A.node[i].y = --y;
        }
        A.step = 0; setnum( A , 1 );
for( int i = 0 ; i< 4 ;i++ )
        {
           scanf( "%d%d",&x , &y );
           B.node[i].x = --x;
           B.node[i].y = --y;
        }
        B.step  = 0; setnum( B, 2 );
        sort( A.node ,A.node + 4 , cmp );
        sort( B.node , B.node + 4 ,cmp );
        q1.push( A );
        q2.push( B );
if( BFS() ) printf( "YES\n" );
else printf( "NO\n" );        
    }
return 0;    
}

 

转载于:https://www.cnblogs.com/bo-tao/archive/2012/03/03/2378209.html