题目：10196 - Check The Check

思路：水题。。模拟

这个代码，前半部分是在数统机房上课的时候写的，挫了点，懒得改了。

  1. #include <cstdio>
  2. #include <iostream>
  3. #include <algorithm>
  4. #include <cstring>
  5. #include <cmath>
  6. #include <map>
  7. using namespace std;
  8. int dir[8][2]={1,0,1,1,0,1,-1,1,-1,0,-1,-1,0,-1,1,-1};
  9. int move[8][2]={2,1,1,2,-1,2,-2,1,-1,-2,-2,-1,1,-2,2,-1};
  10. char s[9][9];
  11. int cas=0;
  12. int main()
  13. {
  14.     while(1)
  15.     {
  16.         int ans=0;
  17.         for(int i=0;i<8;i++)
  18.         {
  19.             gets(s[i]);
  20.             for(int j=0;j<8;j++)
  21.                 if(s[i][j]=='.')
  22.                     ans++;
  23.         }
  24.         if(ans==64)
  25.             break;
  26.         int ctag=0;
  27.         for(int i=0;i<8;i++)
  28.             for(int j=0;j<8;j++)
  29.             {
  30.                 if(s[i][j]=='.')
  31.                     ;
  32.                 else if(s[i][j]=='b')
  33.                 {
  34.                     bool t_left=1,t_right=1;
  35.                     // down
  36.                     for(int k=1;;k++)
  37.                     {
  38.                         if(i+k<8)
  39.                         {
  40.                             if(t_left&&j-k>=0)
  41.                             {
  42.                                 if(s[i+k][j-k]=='K')
  43.                                 {
  44.                                     ctag=1;/// black win
  45.                                     break;
  46.                                 }
  47.                                 else if(s[i+k][j-k]!='.')
  48.                                 {
  49.                                     t_left=0;
  50.                                 }
  51.                             }
  52.                         }
  53.                         else
  54.                             break;
  55.                     }
  56.                     for(int k=1;;k++)
  57.                     {
  58.                         if(i+k<8)
  59.                         {
  60.                             if(t_right&&j+k<8)
  61.                             {
  62.                                 if(s[i+k][j+k]=='K')
  63.                                 {
  64.                                     ctag=1; /// black win
  65.                                     break;
  66.                                 }
  67.                                 else if(s[i+k][j+k]!='.')
  68.                                 {
  69.                                     t_right=0;
  70.                                 }
  71.                             }
  72.                         }
  73.                         else
  74.                             break;
  75.                     }
  76.                     // up
  77.                     t_right=1,t_left=1;
  78.                     for(int k=1;;k++)
  79.                     {
  80.                         if(i-k>=0)
  81.                         {
  82.                             if(t_left&&j-k>=0)
  83.                             {
  84.                                 if(s[i-k][j-k]=='K')
  85.                                 {
  86.                                     ctag=1;/// black win
  87.                                     break;
  88.                                 }
  89.                                 else if(s[i-k][j-k]!='.')
  90.                                 {
  91.                                     t_left=0;
  92.                                 }
  93.                             }
  94.                         }
  95.                         else
  96.                             break;
  97.                     }
  98.                     for(int k=1;;k++)
  99.                     {
  100.                         if(i-k>=0)
  101.                         {
  102.                             if(t_right&&j+k<8)
  103.                             {
  104.                                 if(s[i-k][j+k]=='K')
  105.                                 {
  106.                                     ctag=1; /// black win
  107.                                     break;
  108.                                 }
  109.                                 else if(s[i-k][j+k]!='.')
  110.                                 {
  111.                                     t_right=0;
  112.                                 }
  113.                             }
  114.                         }
  115.                         else
  116.                             break;
  117.                     }
  118.                 }
  119.                 else if(s[i][j]=='B')
  120.                 {
  121.                     bool t_left=1,t_right=1;
  122.                     // down
  123.                     for(int k=1;;k++)
  124.                     {
  125.                         if(i+k<8)
  126.                         {
  127.                             if(t_left&&j-k>=0)
  128.                             {
  129.                                 if(s[i+k][j-k]=='k')
  130.                                 {
  131.                                     ctag=-1;/// white win
  132.                                     break;
  133.                                 }
  134.                                 else if(s[i+k][j-k]!='.')
  135.                                 {
  136.                                     t_left=0;
  137.                                 }
  138.                             }
  139.                         }
  140.                         else
  141.                             break;
  142.                     }
  143.                     for(int k=1;;k++)
  144.                     {
  145.                         if(i+k<8)
  146.                         {
  147.                             if(t_right&&j+k<8)
  148.                             {
  149.                                 if(s[i+k][j+k]=='k')
  150.                                 {
  151.                                     ctag=-1; /// white win
  152.                                     break;
  153.                                 }
  154.                                 else if(s[i+k][j+k]!='.')
  155.                                 {
  156.                                     t_right=0;
  157.                                 }
  158.                             }
  159.                         }
  160.                         else
  161.                             break;
  162.                     }
  163.                     // up
  164.                     t_right=1,t_left=1;
  165.                     for(int k=1;;k++)
  166.                     {
  167.                         if(i-k>=0)
  168.                         {
  169.                             if(t_left&&j-k>=0)
  170.                             {
  171.                                 if(s[i-k][j-k]=='k')
  172.                                 {
  173.                                     ctag=-1;/// white win
  174.                                     break;
  175.                                 }
  176.                                 else if(s[i-k][j-k]!='.')
  177.                                 {
  178.                                     t_left=0;
  179.                                 }
  180.                             }
  181.                         }
  182.                         else
  183.                             break;
  184.                     }
  185.                     for(int k=1;;k++)
  186.                     {
  187.                         if(i-k>=0)
  188.                         {
  189.                             if(t_right&&j+k<8)
  190.                             {
  191.                                 if(s[i-k][j+k]=='k')
  192.                                 {
  193.                                     ctag=-1; /// white win
  194.                                     break;
  195.                                 }
  196.                                 else if(s[i-k][j+k]!='.')
  197.                                 {
  198.                                     t_right=0;
  199.                                 }
  200.                             }
  201.                         }
  202.                         else
  203.                             break;
  204.                     }
  205.                 }
  206.                 else if(s[i][j]=='R')
  207.                 {
  208.                     bool right=1,up=1,down=1,left=1;
  209.                     for(int k=1;;k++)
  210.                     {
  211.                         if(right&&j+k<8)
  212.                         {
  213.                             if(s[i][j+k]=='k')
  214.                             {
  215.                                 ctag=-1;
  216.                                 break;
  217.                             }
  218.                             else if(s[i][j+k]!='.')
  219.                             {
  220.                                 right=0;
  221.                             }
  222.                         }
  223.                         else
  224.                             break;
  225.                     }
  226.                     for(int k=1;;k++)
  227.                     {
  228.                         if(left&&j-k>=0)
  229.                         {
  230.                             if(s[i][j-k]=='k')
  231.                             {
  232.                                 ctag=-1;
  233.                                 break;
  234.                             }
  235.                             else if(s[i][j-k]!='.')
  236.                             {
  237.                                 left=0;
  238.                             }
  239.                         }
  240.                         else
  241.                             break;
  242.                     }
  243.                     for(int k=1;;k++)
  244.                     {
  245.                         if(up&&i-k>=0)
  246.                         {
  247.                             if(s[i-k][j]=='k')
  248.                             {
  249.                                 ctag=-1;
  250.                                 break;
  251.                             }
  252.                             else if(s[i-k][j]!='.')
  253.                             {
  254.                                 up=0;
  255.                             }
  256.                         }
  257.                         else
  258.                             break;
  259.                     }
  260.                     for(int k=1;;k++)
  261.                     {
  262.                         if(down&&i+k<8)
  263.                         {
  264.                             if(s[i+k][j]=='k')
  265.                             {
  266.                                 ctag=-1;
  267.                                 break;
  268.                             }
  269.                             else if(s[i+k][j]!='.')
  270.                             {
  271.                                 down=0;
  272.                             }
  273.                         }
  274.                         else
  275.                             break;
  276.                     }
  277.                 }
  278.                 else if(s[i][j]=='r')
  279.                 {
  280.                     bool right=1,up=1,down=1,left=1;
  281.                     for(int k=1;;k++)
  282.                     {
  283.                         if(right&&j+k<8)
  284.                         {
  285.                             if(s[i][j+k]=='K')
  286.                             {
  287.                                 ctag=1;
  288.                                 break;
  289.                             }
  290.                             else if(s[i][j+k]!='.')
  291.                             {
  292.                                 right=0;
  293.                             }
  294.                         }
  295.                         else
  296.                             break;
  297.                     }
  298.                     for(int k=1;;k++)
  299.                     {
  300.                         if(left&&j-k>=0)
  301.                         {
  302.                             if(s[i][j-k]=='K')
  303.                             {
  304.                                 ctag=1;
  305.                                 break;
  306.                             }
  307.                             else if(s[i][j-k]!='.')
  308.                             {
  309.                                 left=0;
  310.                             }
  311.                         }
  312.                         else
  313.                             break;
  314.                     }
  315.                     for(int k=1;;k++)
  316.                     {
  317.                         if(up&&i-k>=0)
  318.                         {
  319.                             if(s[i-k][j]=='K')
  320.                             {
  321.                                 ctag=1;
  322.                                 break;
  323.                             }
  324.                             else if(s[i-k][j]!='.')
  325.                             {
  326.                                 up=0;
  327.                             }
  328.                         }
  329.                         else
  330.                             break;
  331.                     }
  332.                     for(int k=1;;k++)
  333.                     {
  334.                         if(down&&i+k<8)
  335.                         {
  336.                             if(s[i+k][j]=='K')
  337.                             {
  338.                                 ctag=1;
  339.                                 break;
  340.                             }
  341.                             else if(s[i+k][j]!='.')
  342.                             {
  343.                                 down=0;
  344.                             }
  345.                         }
  346.                         else
  347.                             break;
  348.                     }
  349.                 }
  350.                 else if(s[i][j]=='p')
  351.                 {
  352.                     if(i+1<8)
  353.                     {
  354.                         if(j+1<8)
  355.                         {
  356.                             if(s[i+1][j+1]=='K')
  357.                             {
  358.                                 ctag=1;
  359.                             }
  360.                         }
  361.                         if(j-1>=0)
  362.                         {
  363.                             if(s[i+1][j-1]=='K')
  364.                             {
  365.                                 ctag=1;
  366.                             }
  367.                         }
  368.                     }
  369.                 }
  370.                 else if(s[i][j]=='P')
  371.                 {
  372.                     if(i-1>=0)
  373.                     {
  374.                         if(j+1<8)
  375.                         {
  376.                             if(s[i-1][j+1]=='k')
  377.                             {
  378.                                 ctag=-1;
  379.                             }
  380.                         }
  381.                         if(j-1>=0)
  382.                         {
  383.                             if(s[i-1][j-1]=='k')
  384.                             {
  385.                                 ctag=-1;
  386.                             }
  387.                         }
  388.                     }
  389.                 }
  390.                 else if(s[i][j]=='k')
  391.                 {
  392.                     for(int c=0;c<8;c++)
  393.                     {
  394.                         int xx=i+dir[c][0];
  395.                         int yy=j+dir[c][1];
  396.                         if(xx>=0&&xx<8&&yy>=0&&yy<8)
  397.                         {
  398.                             if(s[xx][yy]=='K')
  399.                             {
  400.                                 ctag=1;
  401.                             }
  402.                         }
  403.                     }
  404.                 }
  405.                 else if(s[i][j]=='K')
  406.                 {
  407.                     for(int c=0;c<8;c++)
  408.                     {
  409.                         int xx=i+dir[c][0];
  410.                         int yy=j+dir[c][0];
  411.                         if(xx>=0&&xx<8&&yy>=0&&yy<8)
  412.                         {
  413.                             if(s[xx][yy]=='k')
  414.                             {
  415.                                 ctag=-1;
  416.                             }
  417.                         }
  418.                     }
  419.                 }
  420.                 else if(s[i][j]=='N')
  421.                 {
  422.                     for(int c=0;c<8;c++)
  423.                     {
  424.                         int xx=i+move[c][0];
  425.                         int yy=j+move[c][1];
  426.                         if(xx>=0&&xx<8&&yy>=0&&yy<8)
  427.                         {
  428.                             if(s[xx][yy]=='k')
  429.                             {
  430.                                 ctag=-1;
  431.                             }
  432.                         }
  433.                     }
  434.                 }
  435.                 else if(s[i][j]=='n')
  436.                 {
  437.                     for(int c=0;c<8;c++)
  438.                     {
  439.                         int xx=i+move[c][0];
  440.                         int yy=j+move[c][1];
  441.                         if(xx>=0&&xx<8&&yy>=0&&yy<8)
  442.                         {
  443.                             if(s[xx][yy]=='K')
  444.                             {
  445.                                 ctag=1;
  446.                             }
  447.                         }
  448.                     }
  449.                 }
  450.                 else if(s[i][j]=='q')
  451.                 {
  452.                     for(int c=0;c<8;c++)
  453.                     {
  454.                         for(int k=1;;k++)
  455.                         {
  456.                             int xx=i+dir[c][0]*k;
  457.                             int yy=j+dir[c][1]*k;
  458.                             if(xx>=0&&xx<8&&yy>=0&&yy<8)
  459.                             {
  460.                                 if(s[xx][yy]=='K')
  461.                                 {
  462.                                     ctag=1;
  463.                                     break;
  464.                                 }
  465.                                 else if(s[xx][yy]!='.')
  466.                                     break;
  467.                             }
  468.                             else
  469.                                 break;
  470.                         }
  471.                     }
  472.                 }
  473.                 else if(s[i][j]=='Q')
  474.                 {
  475.                     for(int c=0;c<8;c++)
  476.                     {
  477.                         for(int k=1;;k++)
  478.                         {
  479.                             int xx=i+dir[c][0]*k;
  480.                             int yy=j+dir[c][1]*k;
  481.                             if(xx>=0&&xx<8&&yy>=0&&yy<8)
  482.                             {
  483.                                 if(s[xx][yy]=='k')
  484.                                 {
  485.                                     ctag=-1;
  486.                                     break;
  487.                                 }
  488.                                 else if(s[xx][yy]!='.')
  489.                                     break;
  490.                             }
  491.                             else
  492.                                 break;
  493.                         }
  494.                     }
  495.                 }
  496.                 //printf("%c",s[i][j]);
  497.             }
  498.  
  499.         printf("Game #%d: ",++cas);
  500.         if(ctag==-1)
  501.             printf("black king is in check.\n");
  502.         else if(ctag==1)
  503.             printf("white king is in check.\n");
  504.         else
  505.             printf("no king is in check.\n");
  506.         getchar();
  507.     }
  508.     return 0;
  509. }

uva 10196 Check The Check的更多相关文章

  1. 烟大 Contest1024 - 《挑战编程》第一章：入门 Problem G: Check The Check（模拟国际象棋）

    Problem G: Check The Check Time Limit: 1 Sec  Memory Limit: 64 MBSubmit: 10  Solved: 3[Submit][Statu ...

  2. UVA - 10196：Check The Check

    类型:简单模拟 大致题意:已知国际象棋行棋规则,给你一个局面,问是否将军?谁将谁的军?(保证不会同时将军) 思路:都以小写字母 测试 是否将 大写字母. 然后一个局面测两次(一次直接测,一次反转棋盘, ...

  3. UVA 10196 Morning Walk（欧拉回路）

    Problem H Morning Walk Time Limit 3 Seconds Kamalis a Motashotaguy. He has got a new job in Chittago ...

  4. SQL PRIMARY KEY 约束\SQL FOREIGN KEY 约束\SQL CHECK 约束

    SQL PRIMARY KEY 约束 PRIMARY KEY 约束唯一标识数据库表中的每条记录. 主键必须包含唯一的值. 主键列不能包含 NULL 值. 每个表都应该有一个主键,并且每个表只能有一个主 ...

  5. check约束条件

    --约束:对列的值起一个约束性的作用,规定列的值的范围 --主键.外键.非空.自增长标识列.唯一列(unique).check约束 --check 约束 --在某个表里点击右键→设计→进去找到要约束的 ...

  6. Health Check in eShop -- 解析微软微服务架构Demo（五）

    引言 What is the Health Check Health Check(健康状态检查)不仅是对自己应用程序内部检测各个项目之间的健康状态(各项目的运行情况.项目之间的连接情况等),还包括了应 ...

  7. SQLServer之修改CHECK约束

    使用SSMS数据库管理工具修改CHECK约束 1.打开数据库,选择数据表->右键点击->选择设计(或者展开约束,选择约束,右键点击,选择修改,后面步骤相同). 2.选择要修改的数据列-&g ...

  8. SQL CHECK 约束

    SQL CHECK 约束 CHECK 约束用于限制列中的值的范围. 如果对单个列定义 CHECK 约束,那么该列只允许特定的值. 如果对一个表定义 CHECK 约束,那么此约束会在特定的列中对值进行限 ...

  9. 约束4：唯一约束，Check约束和null

    大家知道,关系型数据库的逻辑运算的结果是三值型的,TRUE,FALSE和UNKNOWN,特别是,NULL值和任何值都不相等,任何值和NULL的比较,返回的逻辑结果都是unknown.而NULL值在唯一 ...

随机推荐

  1. Linux 下IOport编程訪问

    曾经写的一篇笔记.偶尔翻出来了,放在这里做个纪念 Linux 下IOport编程訪问 这里记录的方法是在用户态訪问IOport,不涉及驱动程序的编写. 首先要包括头文件 /usr/include/as ...

  2. ArrayList集合-[长度问题]--C#

    list.Count//获取集合中实际元素的个数.list.Capacity//获取集合中可包含的元素数. /** *   每次集合中实际包含元素的个数(Count)超过了可以包含的元素的个数(Cap ...

  3. cocos2d-x游戏开发系列教程-坦克大战游戏之敌方坦克AI的编写

    在上篇我们完成了子弹和地图碰撞的检测,在这篇我们将完成敌方坦克AI的编写. 具体思路是屏幕中保持有四个敌方坦克,然后坦克随机方向运动,并且子弹消失后1秒发射一次 1.我们新建一个敌方坦克的AI类来控制 ...

  4. grunt 前端开发环境搭建

    1.找管理员开通gitlab权限 2.下载并安装git工具 3.下载并安装nodejs 4.安装cnpm 5.安装kulor-cli cnpm install -g kulor-cli cnpm in ...

  5. mpi中利用自定义归约操作实现merge

    在归并排序中,很重要的一步是将两个排序数组合并成一个数组,这个操作叫merge.merge操作可以用来解决某些Top K问题. 问题描述 在哼唱搜索中,用户通过哼唱一个音乐片段去搜索与其相似的音乐.后 ...

  6. 开发板和centos服务器tftp传文件

    CentOS下使用TFTP向目标板传送文件http://www.linuxidc.com/Linux/2010-10/29218.htm 1.安装相关软件包 为了使主机支持TFTP,必须确保TFTP后 ...

  7. android自定义控件---添加表情

    android自定义控件---添加表情 一.定义layout文件,图片不提供了 <?xml version="1.0" encoding="utf-8"? ...

  8. WCF技术剖析之十一：异步操作在WCF中的应用（上篇）

    原文:WCF技术剖析之十一:异步操作在WCF中的应用(上篇) 按照操作执行所需的资源类型,我们可以将操作分为CPU绑定型(CPU Bound)操作和I/O绑定型(I/O Bound)操作.对于前者,操 ...

  9. 基于visual Studio2013解决面试题之0907大数乘法

     题目

  10. 《C陷阱与缺陷》整理二

    1.数组名作实參     在C语言中,我们没有办法将一个数组作为函数參数传递,假设我们使用数组名作为參数.这个时候数组名立马会被转换为指向该数组的第一个元素的指针.     关于这一点的理解能够向前深 ...