2003年广东省赛试题3 国际象棋

#include  < iostream >
#include  < string >
#include  < cmath >
using   namespace  std;

enum  TResult
{ // 结局状态
    WHITEWIN  =   1 , // 白方赢
    BLACKWIN, // 黑方赢
    STALEMATE, // 僵局
    DRAW, // 和局
    DEAD, // 过多的输入
    PUZZLE, // 无法决定移动棋子
    ILLEGAL  // 非法
};
const   char  RESULT[ 8 ][ 20 ] =
{ // 结局状态输出表示
     "" ,
     " White Win " ,
     " Black Win " ,
     " Stalemate " ,
     " Draw " ,
     " Dead Moves " ,
     " Puzzle Move " ,
     " Illegal Move "
};
enum  TPieceType
{ // 棋子类型
    SPACE  =   0 ,
    PAWN, // 兵
    KING, // 王
    QUEEN, // 后
    ROOK, // 车
    BISHOP, // 象
    KNIGHT  // 马
};
enum  TSide
{
    NONE  =   0 ,
    WHITE, // 黑方
    BLACK  // 白方
};
typedef  struct
{ // 棋盘每个位置的表示
    TSide side; // 所属玩家
    TPieceType pt; // 棋子类型
}TPiece;
const   int  BOARDSIZE  =   8 ; // 棋盘大小

typedef TPiece TBoard[BOARDSIZE][BOARDSIZE]; // 棋盘
int  n; // 棋谱步数
TResult result; // 最后结局
/*
*用来进行王车易位的布尔变量
*
* whitecastled:白方是否已经王车易位
* blackcastled:黑方是否已经王车易位
* white0rookMoved: 白方号位的车是否已经移动
* white7rookMoved: 白方号位的车是否已经移动
* black0rookMoved: 黑方号位的车是否已经移动
* black7rookMoved: 黑方号位的车是否已经移动
* whitekingMoved: 白方王是否已经移动
* blackkingMoved: 黑方王是否已经移动
*
*/
bool  whitecastled,blackcastled,white0rookMoved,white7rookMoved,black0rookMoved,black7rookMoved,whitekingMoved,blackkingMoved;

TPieceType ChessType( const   string &  move)
{
     switch (move[ 0 ])
    {
     case   ' K ' : // 王
         return  KING;
     case   ' Q ' : // 后
         return  QUEEN;
     case   ' R ' : // 车
         return  ROOK;
     case   ' B ' : // 象
         return  BISHOP;
     case   ' N ' : // 马
         return  KNIGHT;
    }
     return  PAWN; // 兵
}
TSide Opponent(TSide side)
{ // 获取对手类型
     if  (side == WHITE)
         return  BLACK;
     return  WHITE;
}
void  clear(TBoard b, int  x, int  y)
{ // 清空棋盘b的(x,y)位置
    b[x][y].side  =  NONE; // 所属玩家
    b[x][y].pt  =  SPACE; // 棋子类型
}

void  init(TBoard b)
{ // 初始化棋盘
     int  i,j;
     // 清空整个棋盘
     for (i = 0 ;i < BOARDSIZE; ++ i)
         for (j = 0 ;j < BOARDSIZE; ++ j)
        {
            clear(b,i,j);
        }
         // 摆放各个棋子
         for (i = 0 ;i < BOARDSIZE; ++ i)
        {
             // 棋盘前两行是白方
            b[ 0 ][i].side  =  WHITE;
            b[ 1 ][i].side  =  WHITE;
            b[ 1 ][i].pt  =  PAWN; // 上面第二行是白方的兵
             // 棋盘最后两行是黑方
            b[ 6 ][i].side  =  BLACK;
            b[ 7 ][i].side  =  BLACK;
            b[ 6 ][i].pt  =  PAWN; // 倒数第二行是黑方的兵
        }
        b[ 0 ][ 0 ].pt  =  b[ 0 ][ 7 ].pt  =  b[ 7 ][ 0 ].pt  =  b[ 7 ][ 7 ].pt  =  ROOK; // 初始化车的位置
        b[ 0 ][ 1 ].pt  =  b[ 0 ][ 6 ].pt  =  b[ 7 ][ 1 ].pt  =  b[ 7 ][ 6 ].pt  =  KNIGHT; // 初始化马的位置
        b[ 0 ][ 2 ].pt  =  b[ 0 ][ 5 ].pt  =  b[ 7 ][ 2 ].pt  =  b[ 7 ][ 5 ].pt  =  BISHOP; // 初始化象的位置
        b[ 0 ][ 3 ].pt  =  b[ 7 ][ 3 ].pt  =  QUEEN; // 初始化后的位置
        b[ 0 ][ 4 ].pt  =  b[ 7 ][ 4 ].pt  =  KING; // 初始化王的位置
         // 初始化王车易位使用的布尔变量
        whitecastled  =   false ;
        blackcastled  =   false ;
        white0rookMoved  =   false ;
        white7rookMoved  =   false ;
        black0rookMoved  =   false ;
        black7rookMoved  =   false ;
        whitekingMoved  =   false ;
        blackkingMoved  =   false ;
}    
void  SkipInput( int  k)
{ // 棋局已经结束，忽略剩余的输入
     int  i;
     char  mv[ 20 ];
     for (i = k;i < n; ++ i)
    {
        scanf_s( " %s " ,mv);
    }
}
void  GetPosition( const   string &  move, int   & x, int   & y)
{ // 从输入的移动步骤中获取棋子的目标位置
     int  k  =   0 ;
     if (move[ 0 ] < ' a ' ) // 首字母是大写字母
        k  =   1 ;
    x  =  move[k + 1 ] - ' 1 ' ; // 行
    y  =  move[k] - ' a ' ; // 列
}
bool  OutOfBoard( int  x, int  y)
{ // 棋子是否超出棋盘界限
     if  (x < 0 || y < 0 )
    {
         return   true ;
    }
     if  (x > BOARDSIZE || y > BOARDSIZE)
    {
         return   true ;
    }
     return   false ;
}
bool  CanMovePawn(TBoard b, int  x, int  y, int  x2, int  y2, int  flag)
{ // 判断能否把兵从(x,y)移动到(x2,y2),当flag=1时，表示(x,y)直接移动到(x2,y2),flag为其他表示从(x,y)吃子到(x2,y2)
     if  (flag == 1 )
    { // 直接移动，即兵直线前进一格
         if  (y != y2 || b[x2][y2].side != NONE)
        { // y坐标不能改变，无法前进
             return   false ;
        }
         if  (b[x][y].side == WHITE)
        { // 下棋的是白方
             if  (x == 1 )
            { // 白方的兵是第一次移动
                 return  x2 == 2   ||  (x2 == 3 && b[ 2 ][y].side == NONE); // 第一次移动兵可以移动格或格
            }
             else
            {
                 return  x2 == x + 1 ; // 不是第一次移动，就只能向前移动格
            }
        }
         else
        { // 下棋的是黑方
             if  (x == 6 )
            { // 黑方的兵是第一次移动
                 return  x2 == 5   ||  (x2 == 4 && b[ 5 ][y].side == NONE); // 第一次移动兵可以移动格或格
            }
             else
            {
                 return  x2 == x - 1 ; // 不是第一次移动，就只能向前移动格
            }
        }
    }
     else
    { // 吃子判断,吃子时，x向前格，y坐标改变格
         if  (b[x][y].side == WHITE)
        { // 要吃子的是白方
             return  (x2 == x + 1 && abs(y2 - y) == 1 );
        }
         else  
        { // 要吃子的是黑方
             return  (x2 == x - 1 && abs(y2 - y) == 1 );
        }
    }
     return   false ;
}

bool  CanMoveKing(TBoard b, int  x, int  y, int  x2, int  y2)
{ // 判断能否把王从(x,y)移动到(x2,y2)
     return  (abs(x - x2) <= 1 && abs(y - y2) <= 1 );
}
bool  CanMoveRook(TBoard b, int  x, int  y, int  x2, int  y2)
{ // 判断能否把车从(x,y)移动到(x2,y2)
     int  dx,dy,i,xx,yy;
     // 判断移动是否是直线
     if  (x != x2  &&  y != y2)
    {
         return   false ;
    }
     // 直线方向增量
     if  (x2 < x)
        dx  =   - 1 ;
     else
        dx  =   1 ;
     if  (y2 < y)
        dy  =   - 1 ;
     else
        dy  =   1 ;
     // x方向上移动
     for  (i = 1 ;i < abs(y - y2); ++ i)
    {
        yy  =  y + i * dy;
         if  (b[x][yy].side != NONE)
        { // 中间有棋子阻挡
             return   false ;
        }
    }
     // y方向上移动
     for  (i = 1 ;i < abs(x - x2); ++ i)
    {
        xx  =  x + i * dx;
         if  (b[xx][y].side != NONE)
        { // 中间有棋子阻挡
             return   false ;
        }
    }
     return   true ;
}

bool  CanMoveBishop(TBoard b, int  x, int  y, int  x2, int  y2)
{ // 判断能否把象从(x,y)移动到(x2,y2)
     int  dx,dy,i,xx,yy;
     // 是否斜向移动
     if  (abs(x - x2) != abs(y - y2))
    {
         return   false ;
    }
     // 直线方向增量
     if  (x2 < x)
        dx  =   - 1 ;
     else
        dx  =   1 ;
     if  (y2 < y)
        dy  =   - 1 ;
     else
        dy  =   1 ;
     for  (i = 1 ;i < abs(x - x2); ++ i)
    {
        xx  =  x + i * dx;
        yy  =  y + i * dy;
         if  (b[xx][yy].side != NONE)
        { // 中间有棋子阻挡
             return   false ;
        }
    }
     return   true ;
}
bool  CanMoveQueen(TBoard b, int  x, int  y, int  x2, int  y2)
{ // 判断能否把王从(x,y)移动到(x2,y2)
     return  CanMoveRook(b,x,y,x2,y2)  ||  CanMoveBishop(b,x,y,x2,y2); // 王后等于车+象
}
bool  CanMoveKnight( int  x, int  y, int  x2, int  y2)
{ // 判断马能否从(x,y)移动到(x2,y2)
     int  xx,yy;
    xx  =  abs(x - x2);
    yy  =  abs(y - y2);
     return  (xx + yy == 3   &&  (xx == 1   ||  yy == 1 )); // 马行日，x或者y这两者之一移动格，另一方向移动格
}
bool  CanMove(TBoard b, int  x, int  y, int  x2, int  y2, int  flag)
{ // 判断一个棋子能否从(x,y)移动到(x2,y2),当flag=1时，直接移动，flag=2时，表示把(x2,y2)处的棋子给吃掉
     // 判断是否越界
     if  (OutOfBoard(x,y) || OutOfBoard(x2,y2))
    {
         return   false ;
    }
     // 判断原位置是否有棋子
     if  (b[x][y].side == NONE)
    {
         return   false ;
    }
     // 根据原来位置上棋子的不同类型判断是否合法
     switch  (b[x][y].pt)
    {
     case  PAWN: // 兵
         return  CanMovePawn(b,x,y,x2,y2,flag);
     case  KING: // 王
         return  CanMoveKing(b,x,y,x2,y2);
     case  QUEEN: // 后
         return  CanMoveQueen(b,x,y,x2,y2);
     case  ROOK: // 车
         return  CanMoveRook(b,x,y,x2,y2);
     case  BISHOP: // 象
         return  CanMoveBishop(b,x,y,x2,y2);
     case  KNIGHT: // 马
         return  CanMoveKnight(x,y,x2,y2);
    }
     return   false ;
}
void  GetSourcePosition(TBoard b, int  x2, int  y2, int   & x, int   & y,TPieceType ct,TSide side)
{ /* 从给出的位置(x2,y2),类型ct和玩家side,求出移动的棋子的原来位置（x,y)，,
 * 当x=-2时，表示有重复移动方案（Puzzle),x=-1时表示没有移动可能(illegal)
  */
     int  i,j,flag  =   1 ;
     if (b[x2][y2].side != NONE) // 目标位置是对手的棋子，则此步为吃子方案
        flag  =   2 ;
     for  (i = 0 ;i < BOARDSIZE; ++ i)
    {
         for  (j = 0 ;j < BOARDSIZE; ++ j)
        {
             if  (b[i][j].side == side && b[i][j].pt == ct)
            { // 原位置合法并且是同一个子
                 if  (CanMove(b,i,j,x2,y2,flag))
                {
                     if  (x ==- 1 )
                    { // 能够移动并且不重复，找到原来棋子的位置
                        x  =  i;
                        y  =  j;
                    }
                     else
                    { // 能够移动并且有方案，说明有重复
                        x  =   - 2 ;
                         return ;
                    }
                }
            }
        }
    }
}
void  MarkRookMove(TSide side, int  x, int  y)
{
     if  (side == WHITE)
    {
         if  (x == 0 )
        {
             if  (y == 0 )
            {
                white0rookMoved  =   true ; // 白方号车已经移动
            }
             if  (y == 7 )
            {
                white7rookMoved  =   true ; // 白方号车已经移动
            }
        }
         return ;
    }
     if  (x == 7 )
    {
         if  (y == 0 )
        {
            black0rookMoved  =   true ; // 黑方号车已经移动
        }
         if  (y == 7 )
        {
            black7rookMoved  =   true ; // 黑方号车已经移动
        }
    }
}

void  ChessMove(TBoard b, int  x, int  y, int  x2, int  y2)
{ // 棋子从(x,y)移动到(x2,y2)
    b[x2][y2].side  =  b[x][y].side;
    b[x2][y2].pt  =  b[x][y].pt;
    clear(b,x,y); // 清空原位置
}
void  MakeMove(TBoard b, const   string &  move,TSide side)
{ // 根据输入的步骤mv,玩家side移动棋子
     int  x,y,x2,y2;
    GetPosition(move,x2,y2); // 目标位置
     if (b[x2][y2].side == side)
    { // 目标位置处已经有我方的棋子了，此步非法
        result  =  ILLEGAL;
         return ;
    }
    x  =   - 1 ;
    GetSourcePosition(b,x2,y2,x,y,ChessType(move),side); // 尝试寻找原位置
     if  (x ==- 1 )
    { // 非法状态
        result  =  ILLEGAL;
         return ;
    }
     else   if  (x ==- 2 )
    { // 重复状态
        result  =  PUZZLE;
         return ;
    }
     // 移动的棋子是车时，设置王车易位布尔变量
     if  (b[x][y].pt == ROOK)
    {
        MarkRookMove(side,x,y);
    }
     // 移动的棋子是王时，设置王车易位布尔变量
     if  (b[x][y].pt == KING)
    {
         if  (side == WHITE) // 白方王移动了
            whitekingMoved  =   true ;
         else // 黑方王移动了
            blackkingMoved  =   true ;
    }
    ChessMove(b,x,y,x2,y2); // 移动棋子
}
bool  GridBeAttack(TBoard b, int  x, int  y,TSide byWho)
{ // 判断位置(x,y)的棋子能否被吃掉
     int  i,j;
     for  (i = 0 ;i < BOARDSIZE; ++ i)
    {
         for  (j = 0 ;j < BOARDSIZE; ++ j)
        {
             if  (b[i][j].side == byWho  &&  CanMove(b,i,j,x,y, 2 ))
            { // 会被对手吃掉的
                 return   true ;
            }
        }
    }
     return   false ;
}
bool  CanCastle(TBoard b,TSide side, int  flag)
{ // 判断是否能够进行王车易位
     int  row,i;
     if  (side == WHITE)
    { // 白方王车易位
         if  (whitekingMoved == true )
        { // 王已经动了，不能王车易位
             return   false ;
        }
         if  (flag == 3 && white7rookMoved == true )
        { // 目标车已经动了，不能王车易位
             return   false ;
        }
         if  (flag == 5 && white0rookMoved == true )
        { // 目标车已经动了，不能王车易位
             return   false ;
        }
    }
     else
    { // 黑方王车易位
         if  (blackkingMoved == true )
        { // 王已经动了
             return   false ;
        }
         if  (flag == 3   &&  black7rookMoved == true )
        { // 目标车已经动了，不能王车易位
             return   false ;
        }
         if  (flag == 5   &&  black0rookMoved == true )
        { // 目标车已经动了，不能王车易位
             return   false ;
        }
    }
     if  (side == WHITE)
        row  =   0 ;
     else
        row  =   7 ;
     if  (flag == 5 )
    {
         for  (i = 1 ;i < 4 ; ++ i)
        {
             if  (b[row][i].side != NONE)
            { // 王车之间是否有棋子，若有则不能易位
                 return   false ;
            }
        }
         for  (i = 0 ;i < 5 ; ++ i)
        {
             if  (GridBeAttack(b,row,i,Opponent(side)) == true )
            { // 在目标位置上会被对手吃掉，不能王车易位
                 return   false ;
            }
        }
    }
     else
    {
         for  (i = 5 ;i < BOARDSIZE - 1 ; ++ i)
        {
             if  (b[row][i].side != NONE)
            { // 王车之间是否有棋子，若有则不能易位
                 return   false ;
            }
        }
         for  (i = 4 ;i < BOARDSIZE; ++ i)
        {
             if  (GridBeAttack(b,row,i,Opponent(side)))
            { // 在目标位置上会被对手吃掉，不能王车易位
                 return   false ;
            }
        }
    }
     return   true ; // 检查符合要求，可以王车易位
}
void  Castle(TBoard b,TSide side, int  flag)
{ // 进行王车易位,flag=3,表示靠近王的车King-side castle,flag=5时，表示Queen-side castle
     int  row;
     if  (side == WHITE)
    {
         if  (whitecastled == true )
        { // 白方是否已经易位，已经易过位，不能再易了
            result  =  ILLEGAL;
             return  ;
        }
         else
            whitecastled  =   true ; // 设置易位变量
    }
     else
    {
         if  (blackcastled == true )
        { // 黑方是否已经易位，已经易过位，不能再易了
            result  =  ILLEGAL;
             return ;
        }
         else
            blackcastled  =   true ;
    }
     if  (CanCastle(b,side,flag) == true )
    { // 判断是否能够易位
         if  (side == WHITE)
        {
            row  =   0 ;
        }
         else
        {
            row  =   7 ;
        }
         if  (flag == 3 )
        { // 进行王车易位
            ChessMove(b,row, 4 ,row, 6 );
            ChessMove(b,row, 7 ,row, 5 );
        }
         else
        {
            ChessMove(b,row, 4 ,row, 2 );
            ChessMove(b,row, 0 ,row, 3 );
        }
    }
     else
    { // 无法王车易位，此步非法
        result  =  ILLEGAL;
    }
}
void  GetKingPosition(TBoard b,TSide side, int   & x, int   & y)
{ // 寻找国王的位置
     int  i,j;
     for  (i = 0 ;i < BOARDSIZE; ++ i)
    {
         for  (j = 0 ;j < BOARDSIZE; ++ j)
        {
             if  (b[i][j].pt == KING  &&  b[i][j].side  ==  side)
            { // 找到指定方的王
                x  =  i;
                y  =  j;
                 return ;
            }
        }
    }
}
bool  BeCheck(TBoard b,TSide side)
{ // 判断是否被“将军"
     int  x,y,i,j;
    TSide oppSide;
    GetKingPosition(b,side,x,y); // 寻找玩家side的王
    oppSide  =  Opponent(side); // 对手
     for  (i = 0 ;i < BOARDSIZE; ++ i)
    {
         for  (j = 0 ;j < BOARDSIZE; ++ j)
        {
             if  (b[i][j].side == oppSide  &&  CanMove(b,i,j,x,y, 2 ) == true )
            { // 判断对手是否能否将军，flag=2表示此步是吃子，
                 return   true ;
            }
        }
    }
     return   false ;
}
void  CopyBoard(TBoard desBoard,TBoard srcBoard)
{ // 复制棋盘
     int  i,j;
     for  (i = 0 ;i < BOARDSIZE; ++ i)
    {
         for  (j = 0 ;j < BOARDSIZE; ++ j)
        {
            desBoard[i][j].pt  =  srcBoard[i][j].pt;
            desBoard[i][j].side  =  srcBoard[i][j].side;
        }
    }
}
bool  NoMoveAvailable(TBoard b,TSide side)
{ // 判断是否是僵局
     int  x,y,x2,y2;
    TBoard b2;
     for  (x = 0 ;x < BOARDSIZE; ++ x)
    {
         for  (y = 0 ;y < BOARDSIZE; ++ y)
        {
             if  (b[x][y].side == side)
            {
                 for  (x2 = 0 ;x2 < BOARDSIZE; ++ x2)
                {
                     for  (y2 = 0 ;y2 < BOARDSIZE; ++ y2)
                    { // 判断side方的王能否从(x,y)走到(x2,y2)
                         if  ((x2 != x  ||  y2 != y)  &&  b[x][y].side != b[x2][y2].side  &&  CanMove(b,x,y,x2,y2, 1 ))
                        {
                             if  (b[x][y].pt == KING)
                            {
                                CopyBoard(b2,b);
                                ChessMove(b2,x,y,x2,y2);
                                 if  ( ! BeCheck(b2,side))
                                { // 判断位置是否被”将军“，没有就不是僵局
                                     return   false ;
                                }
                            }
                             else
                            {
                                 return   false ;
                            }
                        }
                    }
                }
            }
        }
    }
     return   true ;
}
bool  CheckMate(TBoard b,TSide side)
{ // 判断是否已经结束（即是否某一方被将死）
     int  x,y,x2,y2;
    TBoard b2;
     if  ( ! BeCheck(b,side))
    { // 没有被将死
         return   false ;
    }
     for  (x = 0 ;x < BOARDSIZE; ++ x)
    {
         for  (y = 0 ;y < BOARDSIZE; ++ y)
        {
             if  (b[x][y].side == side)
            {
                 for  (x2 = 0 ;x2 < BOARDSIZE; ++ x2)
                {
                     for  (y2 = 0 ;y2 < BOARDSIZE; ++ y2)
                    {
                         if  ((x != x2  ||  y != y2)  &&  b[x2][y2].side != side)
                        {
                             // 王能否从(x,y)移动到(x2,y2)
                             if  (CanMove(b,x,y,x2,y2, 1 ) == true )
                            {
                                CopyBoard(b2,b);
                                ChessMove(b2,x,y,x2,y2);
                                 if  ( ! BeCheck(b2,side) == true )
                                { // 移动后没有被"将军"
                                     return   false ;
                                }
                            }
                             if  (b[x][y].pt == PAWN  &&  CanMove(b,x,y,x2,y2, 2 ) == true )
                            {
                                CopyBoard(b2,b);
                                ChessMove(b2,x,y,x2,y2);
                                 if  ( ! BeCheck(b2,side))
                                {
                                     return   false ;
                                }
                            }
                        }
                    }
                }
            }
        }
    }
     return   true ;
}
void  run(TBoard b)
{ // 下棋过程
     string  move; // 当前步
    TSide side;
    side  =  WHITE; // 起手是白方先走
     int  i;
     for (i = 0 ;i < n; ++ i)
    {
         if (result == WHITEWIN || result == BLACKWIN || result == STALEMATE)
        { // 棋局已经结束，但还有输入没处理完，状态为DEAD
            result  =  DEAD;
            SkipInput(i); // 忽略其余输入
             return ;
        }
        cin >> move; // 输入棋子移动步骤
         if (move[ 0 ] != ' O ' )
        { // 不是王车易位
            MakeMove(b,move,side); // 根据输入的步骤mv，玩家side移动棋子
        }
         else
        { // 王车易位
            Castle(b,side,move.length());
        }
         if  (BeCheck(b,side) == true )
        { // 移动棋子后被对手"将军"
            result  =  ILLEGAL;
        }
         if  (result == PUZZLE  ||  result == ILLEGAL)
        { // 非法输入或不清楚原来的棋子，则跳过数据
            SkipInput(i + 1 );
             return ;
        }
         if  (CheckMate(b,Opponent(side)))
        { // 被”将死“时，判断获胜方
             if  (side == WHITE)
            {
                result  =  WHITEWIN;
            }
             else
            {
                result  =  BLACKWIN;
            }
        
        }
        side  =  Opponent(side); // 换到对方下了
    }
     if  (result == DRAW  &&  NoMoveAvailable(b,side) == true )
    { // 是否是僵局
        result  =  STALEMATE;
    }
}
int  main()
{
    TBoard board; // 棋盘
     // 输入输出重定向
    freopen( " chess.in " , " r " ,stdin);
    freopen( " chess.out " , " w " ,stdout);
     while (cin >> n  &&  n != 0 )
    {
        init(board); // 初始化棋盘
        result  =  DRAW; // 一开始假设结果为和局
        run(board); // 下棋过程
        cout << RESULT[result] << endl;
    }
     return   0 ;
}