一：题目

  1. 系统提示当前旗手W/B（白/黑）下子,例如W下子，那么W下的位置必须是夹住黑色棋子的位置才可以。

  1. 夹住方式：横向、竖向、斜向

  1. 注意落子后将夹住的黑棋吞噬变为白棋

（一）题目详解

  1. .棋盘以数组表示，“W”表示白子，“B”表示黑子，“-”表示空格
  1. .棋盘大小8行8列

（二）样例输入

  1. 2　　　　　　　　　　　　//第一行是游戏局数
  2. --------　　　　　　　　//开始输入棋盘
  3. --------
  4. --------
  5. ---WB---
  6. ---BW---
  7. --------
  8. --------
  9. --------
  10. W　　　　　　　　　　　　//棋盘后，直接输入当前旗手
  11. L　　　　　　　　　　　　//L是提示命令，如果当前有位置可以下子，则提示(3,5) (4,6) (5,3) (6,4) <前面是可以走的坐标>,如果没有位置可以走，提示No legal move. 则轮到对方黑棋下子。
  12. M35　　　　　　　　　　 //M是下子命令，35表示落子在3行5列，落子后显示当前棋盘剩余棋子数 Black - 1 White - 4
  13. L
  14. Q　　　　　　　　　　　 //Q是退出命令，退出时将当前棋盘数据打印
  15. WWWWB---
  16. WWWB----
  17. WWB-----
  18. WB------
  19. --------
  20. --------
  21. --------
  22. --------
  23. B
  24. L
  25. M25
  26. L
  27. Q

（三）样例输出

  1. (,) (,) (,) (,)　　//对于L提示命令
  2. Black -  White - 4　　//对于M35落子命令，提示棋盘当前棋子数
  3. (,) (,) (,)　　　　//对于L提示命令
  4. --------　　　　　　　　　　//对于Q退出命令，打印棋盘
  5. --------
  6. ----W---
  7. ---WW---
  8. ---BW---
  9. --------
  10. --------
  11. --------
  12. No legal move.
  13. Black -  White -
  14. (,)
  15. WWWWB---
  16. WWWWW---
  17. WWB-----
  18. WB------
  19. --------
  20. --------
  21. --------
  22. --------

二：代码实现

（一）第一版本：400+行，但是解析详细

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5.  
  6. #define N 8
  7.  
  8. char QP[N+][N+];    //棋盘信息
  9. char player;    //旗手信息
  10. char OP;    //对手信息
  11.  
  12. bool Oper[];    //获取操作数据

信息获取和展示

  1. //获取棋盘信息、旗手信息
  2. void getQPInfo()
  3. {
  4.     //获取棋盘信息
  5.     for (int i = ; i <= N; i++)
  6.     {
  7.         for (int j = ; j <= N; j++)
  8.             scanf("%c", &QP[i][j]);
  9.         getchar();
  10.     }
  11.     //获取旗手信息、对手信息
  12.     scanf("%c", &player);
  13.     while (player=='\n')
  14.         scanf("%c", &player);
  15.  
  16.     player == 'W' ? OP = 'B' : OP = 'W';
  17.     getchar();
  18. }
  19.  
  20. //打印棋盘信息
  21. void showQPInfo()
  22. {
  23.     for (int i = ; i <= N; i++)
  24.     {
  25.         for (int j = ; j <= N; j++)
  26.             printf("%c", QP[i][j]);
  27.         printf("\n");
  28.     }
  29. }
  30.  
  31. //打印可以走的步数
  32. void printDataOper()
  33. {
  34.     for (int i = ; i <= ; i++)
  35.         if (Oper[i])
  36.             printf("(%d,%d) ", i / , i % );
  37.     printf("\n");
  38. }
  39.  
  40. //打印棋子数目
  41. void printNumber()
  42. {
  43.     int w = , b = ;
  44.     for (int i = ; i <= N; i++)
  45.         for (int j = ; j <= N; j++)
  46.             if (QP[i][j] == 'W')
  47.                 w++;
  48.             else if (QP[i][j] == 'B')
  49.                 b++;
  50.  
  51.     printf("Black - %d White - %d\n", b, w);
  52. }
  53.  
  54. //交换旗手位置
  55. void ExchangePlayer()
  56. {
  57.     if (player == 'W')
  58.     {
  59.         player = 'B';
  60.         OP = 'W';
  61.     }
  62.     else
  63.     {
  64.         player = 'W';
  65.         OP = 'B';
  66.     }
  67. }

若是落子后，将夹住的对方棋子同化《版本二简化》

  1. void dealAllOP(int n, int m)
  2. {
  3.     //判断四周是否有对手棋子
  4.     int x, y;
  5.  
  6.     //先判断左上
  7.     x = n-, y = m-;
  8.     if (x >=  && y >=  && QP[x][y] == OP)
  9.     {
  10.         //夹住对手
  11.         while (QP[x][y] == OP&&x >=  && y >= )
  12.         {
  13.             x--;
  14.             y--;
  15.         }
  16.         if (x >=  && y >=  && QP[x][y] == player)    //对面也是自己棋子，成功夹住，可以吞噬
  17.         {
  18.             x = n - , y = m - ;
  19.             while (x >=  && y >= &&QP[x][y]!='-')
  20.             {
  21.                 QP[x][y] = player;
  22.                 x--;
  23.                 y--;
  24.             }
  25.         }
  26.     }
  27.  
  28.     //再判断上方
  29.     x = n-, y = m;
  30.     if (x >=  && QP[x][y] == OP)
  31.     {
  32.         //夹住对手
  33.         while (QP[x][y] == OP&&x >= )
  34.         {
  35.             x--;
  36.         }
  37.         if (x >=  && QP[x][y] == player)    //对面也是自己棋子，成功夹住，可以吞噬
  38.         {
  39.             x = n - , y = m;
  40.             while (x >=  && QP[x][y] != '-')
  41.             {
  42.                 QP[x][y] = player;
  43.                 x--;
  44.             }
  45.         }
  46.     }
  47.  
  48.     //再判断右上
  49.     x = n - , y = m + ;
  50.     if (x >=  && y<=  && QP[x][y] == OP)
  51.     {
  52.         //夹住对手
  53.         while (QP[x][y] == OP&&x >=  && y <= )
  54.         {
  55.             x--;
  56.             y++;
  57.         }
  58.         if (x >=  && y <=  && QP[x][y] == player)    //对面也是自己棋子，成功夹住，可以吞噬
  59.         {
  60.             x = n - , y = m + ;
  61.             while (x >=  && y <=  && QP[x][y] != '-')
  62.             {
  63.                 QP[x][y] = player;
  64.                 x--;
  65.                 y++;
  66.             }
  67.         }
  68.     }
  69.  
  70.     //再判断左
  71.     y = m - ,x=n;
  72.     if (y >=  && QP[x][y] == OP)
  73.     {
  74.         //夹住对手
  75.         while (QP[x][y] == OP&&y >= )
  76.         {
  77.             y--;
  78.         }
  79.         if (y>= && QP[x][y] == player)    //对面也是自己棋子，成功夹住，可以吞噬
  80.         {
  81.             y = m - , x = n;
  82.             while (y >=  && QP[x][y] != '-')
  83.             {
  84.                 QP[x][y] = player;
  85.                 y--;
  86.             }
  87.         }
  88.     }
  89.  
  90.     //再判断右
  91.     x = n, y = m+;
  92.     if (y <= && QP[x][y] == OP)
  93.     {
  94.         //夹住对手
  95.         while (QP[x][y] == OP&&y <= )
  96.         {
  97.             y++;
  98.         }
  99.         if (y <=  && QP[x][y] == player)    //对面也是自己棋子，成功夹住，可以吞噬
  100.         {
  101.             x = n, y = m + ;
  102.             while (y <=  && QP[x][y] != '-')
  103.             {
  104.                 QP[x][y] = player;
  105.                 y++;
  106.             }
  107.         }
  108.     }
  109.  
  110.     //再判断左下
  111.     x = n + , y = m - ;
  112.     if (x <=  && y >=  && QP[x][y] == OP)
  113.     {
  114.         //夹住对手
  115.         while (QP[x][y] == OP&&x <=  && y >= )
  116.         {
  117.             x++;
  118.             y--;
  119.         }
  120.         if (x <=  && y >=  && QP[x][y] == player)    //对面也是自己棋子，成功夹住，可以吞噬
  121.         {
  122.             x = n + , y = m - ;
  123.             while (x <=  && y >=  && QP[x][y] != '-')
  124.             {
  125.                 QP[x][y] = player;
  126.                 x++;
  127.                 y--;
  128.             }
  129.         }
  130.     }
  131.  
  132.     //再判断下
  133.     x = n + , y = m;
  134.     if (x <=  && QP[x][y] == OP)
  135.     {
  136.         //夹住对手
  137.         while (QP[x][y] == OP&&x <= )
  138.         {
  139.             x++;
  140.         }
  141.         if (x <=  && QP[x][y] == player)    //对面也是自己棋子，成功夹住，可以吞噬
  142.         {
  143.             x = n + , y = m;
  144.             while (x <=  && QP[x][y] != '-')
  145.             {
  146.                 QP[x][y] = player;
  147.                 x++;
  148.             }
  149.         }
  150.     }
  151.  
  152.     //再判断右下
  153.     x = n + , y = m + ;
  154.     if (x <=  && y <=  && QP[x][y] == OP)
  155.     {
  156.         //夹住对手
  157.         while (QP[x][y] == OP&&x <=  && y <= )
  158.         {
  159.             x++;
  160.             y++;
  161.         }
  162.         if (x <=  && y <=  && QP[x][y] == player)    //对面也是自己棋子，成功夹住，可以吞噬
  163.         {
  164.             x = n + , y = m + ;
  165.             while (x <=  && y <=  && QP[x][y] != '-')
  166.             {
  167.                 QP[x][y] = player;
  168.                 x++;
  169.                 y++;
  170.             }
  171.         }
  172.     }
  173. }

判断对方棋子四周8个方向是否可以落子《版本二简化》

  1. bool judgePlayAtSite(int n,int m)
  2. {
  3.     bool flag = false;
  4.     int x, y;
  5.  
  6.     //先判断左上
  7.     x = n, y = m;
  8.     if ((x - ) >=  && (y - ) >=  && QP[x - ][y - ] == '-')
  9.     {
  10.         //可以落子，判断是否合理
  11.         while (QP[x][y]==OP&&x<=&&y<=)
  12.         {
  13.             x++;
  14.             y++;
  15.         }
  16.         if (x <=  && y <= &&QP[x][y] == player)    //位置合理 落子合理
  17.         {
  18.             Oper[(n-) *  + m-] = true;
  19.             flag = true;
  20.         }
  21.     }
  22.  
  23.     //再判断上方
  24.     x = n, y = m;
  25.     if ((x - ) >= && QP[x - ][y] == '-')
  26.     {
  27.         //可以落子，判断是否合理
  28.         while (QP[x][y] == OP&&x <= )
  29.             x++;
  30.         if (x <=  && QP[x][y] == player)    //位置合理 落子合理
  31.         {
  32.             Oper[(n - ) *  + m] = true;
  33.             flag = true;
  34.         }
  35.     }
  36.  
  37.     //再判断右上
  38.     x = n, y = m;
  39.     if ((x - ) >=  && (y + ) <=  && QP[x - ][y + ] == '-')
  40.     {
  41.         //可以落子，判断是否合理
  42.         while (QP[x][y] == OP&&x <=  && y >= )
  43.         {
  44.             x++;
  45.             y--;
  46.         }
  47.         if (x <=  && y >=  && QP[x][y] == player)    //位置合理 落子合理
  48.         {
  49.             Oper[(n-) *  + m+] = true;
  50.             flag = true;
  51.         }
  52.     }
  53.  
  54.     //再判断左
  55.     x = n, y = m;
  56.     if ((y - ) >=  && QP[x][y - ] == '-')
  57.     {
  58.         //可以落子，判断是否合理
  59.         while (QP[x][y] == OP && y <= )
  60.         {
  61.             y++;
  62.         }
  63.         if (y <=  && QP[x][y] == player)    //位置合理 落子合理
  64.         {
  65.             Oper[n *  + m-] = true;
  66.             flag = true;
  67.         }
  68.     }
  69.  
  70.     //再判断右
  71.     x = n, y = m;
  72.     if ((y + ) <= && QP[x][y + ] == '-')
  73.     {
  74.         //可以落子，判断是否合理
  75.         while (QP[x][y] == OP && y >= )
  76.         {
  77.             y--;
  78.         }
  79.         if (y >=  && QP[x][y] == player)    //位置合理 落子合理
  80.         {
  81.             Oper[n *  + m+] = true;
  82.             flag = true;
  83.         }
  84.     }
  85.  
  86.     //再判断左下
  87.     x = n, y = m;
  88.     if ((x + ) <=  && (y - ) >=  && QP[x + ][y - ] == '-')
  89.     {
  90.         //可以落子，判断是否合理
  91.         while (QP[x][y] == OP&&x >=  && y <= )
  92.         {
  93.             x--;
  94.             y++;
  95.         }
  96.         if (x >=  && y <=  && QP[x][y] == player)    //位置合理 落子合理
  97.         {
  98.             Oper[(n+) *  + m-] = true;
  99.             flag = true;
  100.         }
  101.     }
  102.  
  103.     //再判断下
  104.     x = n, y = m;
  105.     if ((x + ) <=  && QP[x + ][y] == '-')
  106.     {
  107.         //可以落子，判断是否合理
  108.         while (QP[x][y] == OP&&x >= )
  109.         {
  110.             x--;
  111.         }
  112.         if (x >=  && QP[x][y] == player)    //位置合理 落子合理
  113.         {
  114.             Oper[(n+) *  + m] = true;
  115.             flag = true;
  116.         }
  117.     }
  118.  
  119.     //再判断右下
  120.     x = n, y = m;
  121.     if ((x + ) <=  && (y + ) <= && QP[x + ][y + ] == '-')
  122.     {
  123.         //可以落子，判断是否合理
  124.         while (QP[x][y] == OP&&x >= && y >= )
  125.         {
  126.             x--;
  127.             y--;
  128.         }
  129.         if (x >=  && y >=  && QP[x][y] == player)    //位置合理 落子合理
  130.         {
  131.             Oper[(n+) *  + m+] = true;
  132.             flag = true;
  133.         }
  134.     }
  135.  
  136.     return flag;
  137. }

判断是否当前旗手是否可以落子

  1. bool judgeRunPlayer()
  2. {
  3.     //初始化步操作
  4.     bool flag = false;
  5.     memset(Oper, false, sizeof(Oper));
  6.  
  7.     //循环棋盘，找到对方棋子，判断对方棋子四周是否可以落子
  8.     for (int i = ; i <= N; i++)
  9.     {
  10.         for (int j = ; j <= N; j++)
  11.         {
  12.             if (QP[i][j] == OP) //判断四周是否可以落子
  13.                 if (judgePlayAtSite(i, j))
  14.                     flag = true;
  15.         }
  16.     }
  17.  
  18.     //如果步数无效，则调换对手
  19.     if (flag == false)
  20.         ExchangePlayer();
  21.     return flag;
  22. }

处理命令

  1. void dealCommand()
  2. {
  3.     char comm;
  4.     int x, y, temp;
  5.     while ()
  6.     {
  7.         scanf("%c", &comm);
  8.         switch (comm)
  9.         {
  10.         case 'M':    //落子
  11.             scanf("%d", &temp);
  12.             x = temp / ;
  13.             y = temp % ;
  14.             //开始处理棋盘信息
  15.             QP[x][y] = player;
  16.             dealAllOP(x, y);
  17.             ExchangePlayer();
  18.             printNumber();    //输出棋盘棋子数
  19.             break;
  20.         case 'L':    //提示信息
  21.             //先判断当前旗手是否可以落子
  22.             if (judgeRunPlayer())    //打印数据
  23.                 printDataOper();
  24.             else
  25.                 printf("No legal move.\n");
  26.             break;
  27.         case 'Q':    //退出游戏、打印棋盘
  28.             showQPInfo();
  29.             printf("\n");
  30.             getchar();
  31.             return;
  32.         }
  33.         getchar();
  34.     }
  35. }

主函数

  1. int main()
  2. {
  3.     FILE* fp = freopen("data3.in", "r", stdin);
  4.     freopen("data3.out", "w", stdout);
  5.     int num;
  6.  
  7.     scanf("%d", &num);
  8.     getchar();
  9.  
  10.     while (num--)
  11.     {
  12.         getQPInfo();
  13.         dealCommand();
  14.     }
  15.  
  16.     freopen("CON", "r", stdin);
  17.     freopen("CON", "w", stdout);
  18.     return ;
  19. }

（二）第二版本：200+行，对两处函数进行了修改，含空行和注释

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5.  
  6. #define N 8
  7.  
  8. char QP[N+][N+];    //棋盘信息
  9. char player;    //旗手信息
  10. char OP;    //对手信息
  11.  
  12. bool Oper[];    //获取操作数据
  13.  
  14. //8个方向 左上、上、右上、左、右、左下、下、右下
  15. int x_dir[] = { -, -, -, , , , ,  };
  16. int y_dir[] = { -, , , -, , -, ,  };    
  17.  
  18. //获取棋盘信息、旗手信息
  19. void getQPInfo()
  20. {
  21.     //获取棋盘信息
  22.     for (int i = ; i <= N; i++)
  23.     {
  24.         for (int j = ; j <= N; j++)
  25.             scanf("%c", &QP[i][j]);
  26.         getchar();
  27.     }
  28.     //获取旗手信息、对手信息
  29.     scanf("%c", &player);
  30.     while (player=='\n')
  31.         scanf("%c", &player);
  32.  
  33.     player == 'W' ? OP = 'B' : OP = 'W';
  34.     getchar();
  35. }
  36. //打印棋盘信息
  37. void showQPInfo()
  38. {
  39.     for (int i = ; i <= N; i++)
  40.     {
  41.         for (int j = ; j <= N; j++)
  42.             printf("%c", QP[i][j]);
  43.         printf("\n");
  44.     }
  45. }
  46. //打印可以走的步数
  47. void printDataOper()
  48. {
  49.     for (int i = ; i <= ; i++)
  50.         if (Oper[i])
  51.             printf("(%d,%d) ", i / , i % );
  52.     printf("\n");
  53. }
  54. //打印棋子数目
  55. void printNumber()
  56. {
  57.     int w = , b = ;
  58.     for (int i = ; i <= N; i++)
  59.         for (int j = ; j <= N; j++)
  60.             if (QP[i][j] == 'W')
  61.                 w++;
  62.             else if (QP[i][j] == 'B')
  63.                 b++;
  64.  
  65.     printf("Black - %d White - %d\n", b, w);
  66. }
  67. //交换旗手位置
  68. void ExchangePlayer()
  69. {
  70.     if (player == 'W')
  71.     {
  72.         player = 'B';
  73.         OP = 'W';
  74.     }
  75.     else
  76.     {
  77.         player = 'W';
  78.         OP = 'B';
  79.     }
  80. }
  81. //判断对方四周是否可以落子
  82. bool judgePlayAtSite(int n, int m)
  83. {
  84.     bool flag = false;
  85.     int x, y;
  86.  
  87.     for (int i = ; i < ; i++)    //循环8个方向
  88.     {
  89.         x = n, y = m;
  90.         if ((x + x_dir[i]) >=  && (x + x_dir[i]) <=  && (y + y_dir[i]) >=  && (y + y_dir[i]) <=  && QP[x + x_dir[i]][y + y_dir[i]] == '-')
  91.         {
  92.             //可以落子，判断是否合理
  93.             while (QP[x][y] == OP&&x <=  && x >=  && y <=  && y >= )
  94.             {
  95.                 x -= x_dir[i];
  96.                 y -= y_dir[i];
  97.             }
  98.             if (x <=  && x >=  && y <=  && y >=  && QP[x][y] == player)    //位置合理 落子合理
  99.             {
  100.                 Oper[(n + x_dir[i]) *  + m + y_dir[i]] = true;
  101.                 flag = true;
  102.             }
  103.         }
  104.     }
  105.  
  106.     return flag;
  107. }
  108. //将当前落子后的棋子夹住的棋子吞噬
  109. void dealAllOP(int n, int m)
  110. {
  111.     //判断四周是否有对手棋子
  112.     int x, y;
  113.  
  114.     for (int i = ; i < ; i++)
  115.     {
  116.         x = n + x_dir[i], y = m + y_dir[i];
  117.         if (x >=  && x <=  && y >=  && y <=  && QP[x][y] == OP)
  118.         {
  119.             //夹住对手
  120.             while (QP[x][y] == OP&&x >=  && x <=  && y >=  && y <= )
  121.             {
  122.                 x += x_dir[i];
  123.                 y += y_dir[i];
  124.             }
  125.             if (x >=  && x <=  && y >=  && y <=  && QP[x][y] == player)    //对面也是自己棋子，成功夹住，可以吞噬
  126.             {
  127.                 x = n + x_dir[i], y = m + y_dir[i];
  128.                 while (x >=  && x <=  && y >=  && y <=  && QP[x][y] != '-')
  129.                 {
  130.                     QP[x][y] = player;
  131.                     x += x_dir[i];
  132.                     y += y_dir[i];
  133.                 }
  134.             }
  135.         }
  136.     }
  137. }
  138. //判断是否当前旗手是否可以落子
  139. bool judgeRunPlayer()
  140. {
  141.     //初始化步操作
  142.     bool flag = false;
  143.     memset(Oper, false, sizeof(Oper));
  144.  
  145.     //循环棋盘，找到对方棋子，判断对方棋子四周是否可以落子
  146.     for (int i = ; i <= N; i++)
  147.     {
  148.         for (int j = ; j <= N; j++)
  149.         {
  150.             if (QP[i][j] == OP) //判断四周是否可以落子
  151.                 if (judgePlayAtSite(i, j))
  152.                     flag = true;
  153.         }
  154.     }
  155.  
  156.     //如果步数无效，则调换对手
  157.     if (flag == false)
  158.         ExchangePlayer();
  159.     return flag;
  160. }
  161. //处理命令
  162. void dealCommand()
  163. {
  164.     char comm;
  165.     int x, y, temp;
  166.     while ()
  167.     {
  168.         scanf("%c", &comm);
  169.         switch (comm)
  170.         {
  171.         case 'M':    //落子
  172.             scanf("%d", &temp);
  173.             x = temp / ;
  174.             y = temp % ;
  175.             //开始处理棋盘信息
  176.             QP[x][y] = player;
  177.             dealAllOP(x, y);
  178.             ExchangePlayer();
  179.             printNumber();    //输出棋盘棋子数
  180.             break;
  181.         case 'L':    //提示信息
  182.             //先判断当前旗手是否可以落子
  183.             if (judgeRunPlayer())    //打印数据
  184.                 printDataOper();
  185.             else
  186.                 printf("No legal move.\n");
  187.             break;
  188.         case 'Q':    //退出游戏、打印棋盘
  189.             showQPInfo();
  190.             printf("\n");
  191.             getchar();
  192.             return;
  193.         }
  194.         getchar();
  195.     }
  196. }
  197. //主函数
  198. void main()
  199. {
  200.     FILE* fp = freopen("data3.in", "r", stdin);
  201.     freopen("data3.out", "w", stdout);
  202.     int num;
  203.     scanf("%d", &num);
  204.     getchar();
  205.  
  206.     while (num--)
  207.     {
  208.         getQPInfo();
  209.         dealCommand();
  210.     }
  211.  
  212.     freopen("CON", "r", stdin);
  213.     freopen("CON", "w", stdout);
  214. }

（三）第三版本：100+行，同网上其他形式，去掉注释，进行空行缩减，语句简写

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #define N 8
  5. char QP[N+][N+];    //棋盘信息
  6. char player;    //旗手信息
  7. char OP;    //对手信息
  8. bool Oper[];    //获取操作数据
  9. int x_dir[] = { -, -, -, , , , ,  };
  10. int y_dir[] = { -, , , -, , -, ,  };
  11. void getQPInfo()
  12. {
  13.     for (int i = ; i <= N; i++)
  14.     {
  15.         for (int j = ; j <= N; j++)
  16.             scanf("%c", &QP[i][j]);
  17.         getchar();
  18.     }
  19.     scanf("%c", &player);
  20.     while (player == '\n') scanf("%c", &player);
  21.     player == 'W' ? OP = 'B' : OP = 'W';
  22.     getchar();
  23. }
  24. void showQPInfo()
  25. {
  26.     for (int i = ; i <= N; i++)
  27.     {
  28.         for (int j = ; j <= N; j++)
  29.             printf("%c", QP[i][j]);
  30.         printf("\n");
  31.     }
  32. }
  33. void printDataOper()
  34. {
  35.     for (int i = ; i <= ; i++)
  36.         if (Oper[i]) printf("(%d,%d) ", i / , i % );
  37.     printf("\n");
  38. }
  39. void printNumber()
  40. {
  41.     int w = , b = ;
  42.     for (int i = ; i <= N; i++)
  43.         for (int j = ; j <= N; j++)
  44.             if (QP[i][j] == 'W') w++;
  45.             else if (QP[i][j] == 'B') b++;
  46.     printf("Black - %d White - %d\n", b, w);
  47. }
  48. void ExchangePlayer()
  49. {
  50.     if (player == 'W') player = 'B', OP = 'W';
  51.     else player = 'W', OP = 'B';
  52. }
  53. bool judgePlayAtSite(int n, int m)
  54. {
  55.     bool flag = false;
  56.     int x, y;
  57.     for (int i = ; i < ; i++)    //循环8个方向
  58.     {
  59.         x = n, y = m;
  60.         if ((x + x_dir[i]) >=  && (x + x_dir[i]) <=  && (y + y_dir[i]) >=  && (y + y_dir[i]) <=  && QP[x + x_dir[i]][y + y_dir[i]] == '-')
  61.         {
  62.             while (QP[x][y] == OP&&x <=  && x >=  && y <=  && y >= )
  63.                 x -= x_dir[i],y -= y_dir[i];
  64.             if (x <=  && x >=  && y <=  && y >=  && QP[x][y] == player)    //位置合理 落子合理
  65.                 Oper[(n + x_dir[i]) *  + m + y_dir[i]] = true,flag = true;
  66.         }
  67.     }
  68.     return flag;
  69. }
  70. void dealAllOP(int n, int m)
  71. {
  72.     int x, y;
  73.     for (int i = ; i < ; i++)
  74.     {
  75.         x = n + x_dir[i], y = m + y_dir[i];
  76.         if (x >=  && x <=  && y >=  && y <=  && QP[x][y] == OP)
  77.         {
  78.             while (QP[x][y] == OP&&x >=  && x <=  && y >=  && y <= )
  79.                 x += x_dir[i],y += y_dir[i];
  80.             if (x >=  && x <=  && y >=  && y <=  && QP[x][y] == player)    //对面也是自己棋子，成功夹住，可以吞噬
  81.             {
  82.                 x = n + x_dir[i], y = m + y_dir[i];
  83.                 while (x >=  && x <=  && y >=  && y <=  && QP[x][y] != '-')
  84.                     QP[x][y] = player,x += x_dir[i],y += y_dir[i];
  85.             }
  86.         }
  87.     }
  88. }
  89. bool judgeRunPlayer()
  90. {
  91.     bool flag = false;
  92.     memset(Oper, false, sizeof(Oper));
  93.     for (int i = ; i <= N; i++)
  94.     {
  95.         for (int j = ; j <= N; j++)
  96.             if (QP[i][j] == OP) //判断四周是否可以落子
  97.                 if (judgePlayAtSite(i, j)) flag = true;
  98.     }
  99.     if (flag == false) ExchangePlayer();
  100.     return flag;
  101. }
  102. void dealCommand()
  103. {
  104.     char comm;
  105.     int x, y, temp;
  106.     while ()
  107.     {
  108.         scanf("%c", &comm);
  109.         switch (comm)
  110.         {
  111.         case 'M':    //落子
  112.             scanf("%d", &temp);
  113.             x = temp / , y = temp % ;
  114.             QP[x][y] = player;
  115.             dealAllOP(x, y);
  116.             ExchangePlayer();
  117.             printNumber();    //输出棋盘棋子数
  118.             break;
  119.         case 'L':    //提示信息
  120.             if (judgeRunPlayer())    printDataOper();//打印数据
  121.             else printf("No legal move.\n");
  122.             break;
  123.         case 'Q':    //退出游戏、打印棋盘
  124.             showQPInfo();
  125.             printf("\n");
  126.             getchar();
  127.             return;
  128.         }
  129.         getchar();
  130.     }
  131. }
  132. void main()
  133. {
  134.     FILE* fp = freopen("data3.in", "r", stdin);
  135.     freopen("data3.out", "w", stdout);
  136.     int num;
  137.     scanf("%d", &num);
  138.     getchar();
  139.     while (num--)
  140.     {
  141.         getQPInfo();
  142.         dealCommand();
  143.     }
  144.     freopen("CON", "r", stdin);
  145.     freopen("CON", "w", stdout);
  146. }

没必要看

算法习题---4-3黑白棋（UVa220）的更多相关文章

  1. 51nod 1368：黑白棋 二分图最大匹配

    1368 黑白棋 题目来源: TopCoder 基准时间限制:1 秒 空间限制:131072 KB 分值: 160 难度:6级算法题  收藏  取消关注 有一个N*M的棋盘(1<=N,M< ...

  2. 用Dart写的黑白棋游戏

    2013年11月,Dart语言1.0稳定版SDK发布,普天同庆.从此,网页编程不再纠结了. 在我看来,Dart语法简直就是C#的升级版,太像了.之所以喜欢Ruby的一个重要理由是支持mixin功能,而 ...

  3. [CareerCup] 8.8 Othello Game 黑白棋游戏

    8.8 Othello is played as follows: Each Othello piece is white on one side and black on the other. Wh ...

  4. 黑白棋游戏 （codevs 2743）题解

    [问题描述] 黑白棋游戏的棋盘由4×4方格阵列构成.棋盘的每一方格中放有1枚棋子,共有8枚白棋子和8枚黑棋子.这16枚棋子的每一种放置方案都构成一个游戏状态.在棋盘上拥有1条公共边的2个方格称为相邻方 ...

  5. bzoj 2281 [Sdoi2011]黑白棋（博弈+组合计数）

    黑白棋(game) [问题描述] 小A和小B又想到了一个新的游戏. 这个游戏是在一个1*n的棋盘上进行的,棋盘上有k个棋子,一半是黑色,一半是白色. 最左边是白色棋子,最右边是黑色棋子,相邻的棋子颜色 ...

  6. C#黑白棋制作~

    前些天自己复习一下C#语言 做了个黑白棋,望大家看一下,可能有些bug嘿嘿 链接如下 http://files.cnblogs.com/files/flyingjun/%E9%BB%91%E7%99% ...

  7. 【BZOJ2281】【博弈论+DP】 [Sdoi2011]黑白棋

    Description 黑白棋(game) [问题描述] 小A和小B又想到了一个新的游戏. 这个游戏是在一个1*n的棋盘上进行的,棋盘上有k个棋子,一半是黑色,一半是白色. 最左边是白色棋子,最右边是 ...

  8. [SDOI2011]黑白棋

    Description 小A和小B又想到了一个新的游戏. 这个游戏是在一个1*n的棋盘上进行的,棋盘上有k个棋子,一半是黑色,一半是白色. 最左边是白色棋子,最右边是黑色棋子,相邻的棋子颜色不同. 小 ...

  9. C++ 黑白棋AI minimax+alphabeta剪枝

    没事写着玩玩,通过debian上的黑白棋测试,搜了10层,打hard应该问题不大 #include <cstdio> #include <cstring> using name ...

  10. 【算法习题】数组中任意2个（3个）数的和为sum的组合

    题1.给定一个int数组,一个数sum,求数组中和为sum的任意2个数的组合 @Test public void test_find2() { int[] arr = { -1, 0, 2, 3, 4 ...

随机推荐

  1. PowerMockito单元测试中的Invalid use of argument matchers问题详解

    首先,简单说说PowerMockito进行单元测试的三部曲: 打桩,即为非测试目标方法设置返回值,这些返回值在测试目标方法中被使用.执行测试,调用测试目标方法.验证测试结果,如测试方法是否被执行,测试 ...

  2. linux网络编程之socket编程(九)

    转眼又快到十一月份了,北京已经是完全进入冬天的节奏,外面冷风嗖嗖的,不过在夜深人静之时,学习永远成了我最快乐的时光,只有此时会觉得自己是如此踏实,虽说白天工作也是编一天程,但是此时的编程,是一种业余爱 ...

  3. sudo 以管理员身份运行脚本--tee方式记录脚本日志

    说明:当运行脚本时,常遇到权限不足等,可以用以上方法来以管理员权限运行 1.编辑/etc/sudoers (注意,这里使用 visudo 而不是 vi 来设置.) 2.visudo或 给与/etc/s ...

  4. Ajax使用方法

    什么是AJAX? AJAX,Asynchronous JavaScript and XML (异步的JavaScript和XML),一种创建交互式网页应用的网页开发技术方案. 异步的JavaScrip ...

  5. js中的数据类型以及转换

    Js中的数据类型 Js中的数据类型一共有六种,即number,string,boolean,underfine,null,object. 一,number Number数据类型指的是数字,可以为整型, ...

  6. 块状链表 bzoj 3343教主的魔法

    //块状链表//分块排序,然后每次查找时在暴力查找头和尾两个块.//中间那些块,因为有序所以只需2分查找即可.我用的是lower_pound();//插入是,也是头和尾暴力插入,中间那些加到一个累计里 ...

  7. Bzoj 1280: Emmy卖猪pigs

    1280: Emmy卖猪pigs Time Limit: 1 Sec  Memory Limit: 162 MBSubmit: 279  Solved: 182[Submit][Status][Dis ...

  8. TensorFlow(六)：tensorboard网络结构

    # MNIST数据集 手写数字 import tensorflow as tf from tensorflow.examples.tutorials.mnist import input_data # ...

  9. requests记录

    http://docs.python-requests.org/zh_CN/latest/user/quickstart.html r = requests.get('http://httpbin.o ...

  10. Beyond compare4密钥

    w4G-in5u3SH75RoB3VZIX8htiZgw4ELilwvPcHAIQWfwfXv5n0IHDp5hv1BM3+H1XygMtiE0-JBgacjE9tz33sIh542EmsGs1yg6 ...