uva 10196 Check The Check

最新推荐文章于 2021-03-24 18:50:31 发布
最新推荐文章于 2021-03-24 18:50:31 发布
阅读量99 收藏
点赞数
本文介绍了一个简单的程序，用于判断国际象棋中黑白两方的国王是否处于被将军的状态。通过对每种棋子的走法规则进行模拟实现，程序能够准确地识别出当前棋局是否有‘将军’的情况发生。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

题目：10196 - Check The Check

思路：水题。。模拟 


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



 

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <map>
using namespace std;
int dir[8][2]={1,0,1,1,0,1,-1,1,-1,0,-1,-1,0,-1,1,-1};
int move[8][2]={2,1,1,2,-1,2,-2,1,-1,-2,-2,-1,1,-2,2,-1};
char s[9][9];
int cas=0;
int main()
{
    while(1)
    {
        int ans=0;
        for(int i=0;i<8;i++)
        {
            gets(s[i]);
            for(int j=0;j<8;j++)
                if(s[i][j]=='.')
                    ans++;
        }
        if(ans==64)
            break;
        int ctag=0;
        for(int i=0;i<8;i++)
            for(int j=0;j<8;j++)
            {
                if(s[i][j]=='.')
                    ;
                else if(s[i][j]=='b')
                {
                    bool t_left=1,t_right=1;
                    // down
                    for(int k=1;;k++)
                    {
                        if(i+k<8)
                        {
                            if(t_left&&j-k>=0)
                            {
                                if(s[i+k][j-k]=='K')
                                {
                                    ctag=1;/// black win
                                    break;
                                }
                                else if(s[i+k][j-k]!='.')
                                {
                                    t_left=0;
                                }
                            }
                        }
                        else
                            break;
                    }
                    for(int k=1;;k++)
                    {
                        if(i+k<8)
                        {
                            if(t_right&&j+k<8)
                            {
                                if(s[i+k][j+k]=='K')
                                {
                                    ctag=1; /// black win
                                    break;
                                }
                                else if(s[i+k][j+k]!='.')
                                {
                                    t_right=0;
                                }
                            }
                        }
                        else
                            break;
                    }
                    // up
                    t_right=1,t_left=1;
                    for(int k=1;;k++)
                    {
                        if(i-k>=0)
                        {
                            if(t_left&&j-k>=0)
                            {
                                if(s[i-k][j-k]=='K')
                                {
                                    ctag=1;/// black win
                                    break;
                                }
                                else if(s[i-k][j-k]!='.')
                                {
                                    t_left=0;
                                }
                            }
                        }
                        else
                            break;
                    }
                    for(int k=1;;k++)
                    {
                        if(i-k>=0)
                        {
                            if(t_right&&j+k<8)
                            {
                                if(s[i-k][j+k]=='K')
                                {
                                    ctag=1; /// black win
                                    break;
                                }
                                else if(s[i-k][j+k]!='.')
                                {
                                    t_right=0;
                                }
                            }
                        }
                        else
                            break;
                    }
                }
                else if(s[i][j]=='B')
                {
                    bool t_left=1,t_right=1;
                    // down
                    for(int k=1;;k++)
                    {
                        if(i+k<8)
                        {
                            if(t_left&&j-k>=0)
                            {
                                if(s[i+k][j-k]=='k')
                                {
                                    ctag=-1;/// white win
                                    break;
                                }
                                else if(s[i+k][j-k]!='.')
                                {
                                    t_left=0;
                                }
                            }
                        }
                        else
                            break;
                    }
                    for(int k=1;;k++)
                    {
                        if(i+k<8)
                        {
                            if(t_right&&j+k<8)
                            {
                                if(s[i+k][j+k]=='k')
                                {
                                    ctag=-1; /// white win
                                    break;
                                }
                                else if(s[i+k][j+k]!='.')
                                {
                                    t_right=0;
                                }
                            }
                        }
                        else
                            break;
                    }
                    // up
                    t_right=1,t_left=1;
                    for(int k=1;;k++)
                    {
                        if(i-k>=0)
                        {
                            if(t_left&&j-k>=0)
                            {
                                if(s[i-k][j-k]=='k')
                                {
                                    ctag=-1;/// white win
                                    break;
                                }
                                else if(s[i-k][j-k]!='.')
                                {
                                    t_left=0;
                                }
                            }
                        }
                        else
                            break;
                    }
                    for(int k=1;;k++)
                    {
                        if(i-k>=0)
                        {
                            if(t_right&&j+k<8)
                            {
                                if(s[i-k][j+k]=='k')
                                {
                                    ctag=-1; /// white win
                                    break;
                                }
                                else if(s[i-k][j+k]!='.')
                                {
                                    t_right=0;
                                }
                            }
                        }
                        else
                            break;
                    }
                }
                else if(s[i][j]=='R')
                {
                    bool right=1,up=1,down=1,left=1;
                    for(int k=1;;k++)
                    {
                        if(right&&j+k<8)
                        {
                            if(s[i][j+k]=='k')
                            {
                                ctag=-1;
                                break;
                            }
                            else if(s[i][j+k]!='.')
                            {
                                right=0;
                            }
                        }
                        else
                            break;
                    }
                    for(int k=1;;k++)
                    {
                        if(left&&j-k>=0)
                        {
                            if(s[i][j-k]=='k')
                            {
                                ctag=-1;
                                break;
                            }
                            else if(s[i][j-k]!='.')
                            {
                                left=0;
                            }
                        }
                        else
                            break;
                    }
                    for(int k=1;;k++)
                    {
                        if(up&&i-k>=0)
                        {
                            if(s[i-k][j]=='k')
                            {
                                ctag=-1;
                                break;
                            }
                            else if(s[i-k][j]!='.')
                            {
                                up=0;
                            }
                        }
                        else
                            break;
                    }
                    for(int k=1;;k++)
                    {
                        if(down&&i+k<8)
                        {
                            if(s[i+k][j]=='k')
                            {
                                ctag=-1;
                                break;
                            }
                            else if(s[i+k][j]!='.')
                            {
                                down=0;
                            }
                        }
                        else
                            break;
                    }
                }
                else if(s[i][j]=='r')
                {
                    bool right=1,up=1,down=1,left=1;
                    for(int k=1;;k++)
                    {
                        if(right&&j+k<8)
                        {
                            if(s[i][j+k]=='K')
                            {
                                ctag=1;
                                break;
                            }
                            else if(s[i][j+k]!='.')
                            {
                                right=0;
                            }
                        }
                        else
                            break;
                    }
                    for(int k=1;;k++)
                    {
                        if(left&&j-k>=0)
                        {
                            if(s[i][j-k]=='K')
                            {
                                ctag=1;
                                break;
                            }
                            else if(s[i][j-k]!='.')
                            {
                                left=0;
                            }
                        }
                        else
                            break;
                    }
                    for(int k=1;;k++)
                    {
                        if(up&&i-k>=0)
                        {
                            if(s[i-k][j]=='K')
                            {
                                ctag=1;
                                break;
                            }
                            else if(s[i-k][j]!='.')
                            {
                                up=0;
                            }
                        }
                        else
                            break;
                    }
                    for(int k=1;;k++)
                    {
                        if(down&&i+k<8)
                        {
                            if(s[i+k][j]=='K')
                            {
                                ctag=1;
                                break;
                            }
                            else if(s[i+k][j]!='.')
                            {
                                down=0;
                            }
                        }
                        else
                            break;
                    }
                }
                else if(s[i][j]=='p')
                {
                    if(i+1<8)
                    {
                        if(j+1<8)
                        {
                            if(s[i+1][j+1]=='K')
                            {
                                ctag=1;
                            }
                        }
                        if(j-1>=0)
                        {
                            if(s[i+1][j-1]=='K')
                            {
                                ctag=1;
                            }
                        }
                    }
                }
                else if(s[i][j]=='P')
                {
                    if(i-1>=0)
                    {
                        if(j+1<8)
                        {
                            if(s[i-1][j+1]=='k')
                            {
                                ctag=-1;
                            }
                        }
                        if(j-1>=0)
                        {
                            if(s[i-1][j-1]=='k')
                            {
                                ctag=-1;
                            }
                        }
                    }
                }
                else if(s[i][j]=='k')
                {
                    for(int c=0;c<8;c++)
                    {
                        int xx=i+dir[c][0];
                        int yy=j+dir[c][1];
                        if(xx>=0&&xx<8&&yy>=0&&yy<8)
                        {
                            if(s[xx][yy]=='K')
                            {
                                ctag=1;
                            }
                        }
                    }
                }
                else if(s[i][j]=='K')
                {
                    for(int c=0;c<8;c++)
                    {
                        int xx=i+dir[c][0];
                        int yy=j+dir[c][0];
                        if(xx>=0&&xx<8&&yy>=0&&yy<8)
                        {
                            if(s[xx][yy]=='k')
                            {
                                ctag=-1;
                            }
                        }
                    }
                }
                else if(s[i][j]=='N')
                {
                    for(int c=0;c<8;c++)
                    {
                        int xx=i+move[c][0];
                        int yy=j+move[c][1];
                        if(xx>=0&&xx<8&&yy>=0&&yy<8)
                        {
                            if(s[xx][yy]=='k')
                            {
                                ctag=-1;
                            }
                        }
                    }
                }
                else if(s[i][j]=='n')
                {
                    for(int c=0;c<8;c++)
                    {
                        int xx=i+move[c][0];
                        int yy=j+move[c][1];
                        if(xx>=0&&xx<8&&yy>=0&&yy<8)
                        {
                            if(s[xx][yy]=='K')
                            {
                                ctag=1;
                            }
                        }
                    }
                }
                else if(s[i][j]=='q')
                {
                    for(int c=0;c<8;c++)
                    {
                        for(int k=1;;k++)
                        {
                            int xx=i+dir[c][0]*k;
                            int yy=j+dir[c][1]*k;
                            if(xx>=0&&xx<8&&yy>=0&&yy<8)
                            {
                                if(s[xx][yy]=='K')
                                {
                                    ctag=1;
                                    break;
                                }
                                else if(s[xx][yy]!='.')
                                    break;
                            }
                            else
                                break;
                        }
                    }
                }
                else if(s[i][j]=='Q')
                {
                    for(int c=0;c<8;c++)
                    {
                        for(int k=1;;k++)
                        {
                            int xx=i+dir[c][0]*k;
                            int yy=j+dir[c][1]*k;
                            if(xx>=0&&xx<8&&yy>=0&&yy<8)
                            {
                                if(s[xx][yy]=='k')
                                {
                                    ctag=-1;
                                    break;
                                }
                                else if(s[xx][yy]!='.')
                                    break;
                            }
                            else
                                break;
                        }
                    }
                }
                //printf("%c",s[i][j]);
            }

        printf("Game #%d: ",++cas);
        if(ctag==-1)
            printf("black king is in check.\n");
        else if(ctag==1)
            printf("white king is in check.\n");
        else
            printf("no king is in check.\n");
        getchar();
    }
    return 0;
}


 

 

Module Check Failed—For the update to proceed, you need tohave the hvigorfile···【鸿蒙报错已解决】
一键难忘的博客
05-02 151
Module Check Failed—For the update to proceed, you need tohave the hvigorfile···【鸿蒙报错已解决】最近遇到了这个问题，看到网上也有人在询问这个问题，实操了很多网上的解决方案发现并不能解决这个Bug，所以我在解决这个问题后，总结了自己和其他人的解决经验，进行了整理，写了一本解决【Module Check Failed—For the update to proceed, you need tohave the hvigorfile
UVA122 树的层次遍历 Trees on the level（两种方法详解）
繁凡さん的博客
02-23 824
UVA122 树的层次遍历 Trees on the level 输入： (11,LL) (7,LLL) (8,R) (5,) (4,L) (13,RL) (2,LLR) (1,RRR) (4,RR) () (3,L) (4,R) () 输出： 5 4 8 11 13 4 7 2 1 not complete //不管是左子树还是右子树，它们的父节点都是P/2; 以下内容来自《算法竞赛入门经...
UVa 10196 Check the Check
Ming.L
04-10 629
#include #include #include char ChessBoard[8][8]; char *WhiteCheck = "white king is in check."; char *BlackCheck = "black king is in check."; char *NoCheck="no king is in check."; int boundary(int
UVA10196 Check The Check【模拟+回溯】
海岛Blog
04-28 960
Your task is to write a program that reads a chess board configuration and answers if there’s a king under attack (i.e. “in check”). A king is in check if it’s in a square which is attacked by an opon...
UVA 10196 Check The Check（模拟）
LYHVOYAGE的专栏
07-10 672
#include #include using namespace std; char Map[8][8]; // 表示国际象棋棋子的位置。 // 检查坐标为（king_x，king_y）的王是否在坐标为（x，y）的卒攻击范围内，注意进攻方向的不同。 bool check_Pp (int x, int y, int king_x, int king_y) { return (x - ki
UVA10196 Check The Check 简单模拟
11-27 622
这道题目代码量有点大。 注意行和列的定义，这里我搞反了，WA了一晚。 代码虽然有很多的重复，但直接复制粘贴的时候注意下小的细节。 注意题目输入数据的时候两组数据之间有一空行。 这道题目不用判断王的走法，因为一个王可以吃到另一个，那么另一个也能吃到他，与题意不符合。 #include #include #include #include #include using namespace
UVa 10196 - Check The Check
小白菜又菜
06-06 1223
题目：国际象棋，判断当前状态，哪一方被将军了。不会有同时被将军的情况。 分析：模拟。直接按照国际象棋的规则模拟即可。             把操作分成两种，单点判断和射线判断，写成函数减少公共代码，也降低错误率；             然后：兵、马、王（不用判断）都是单点判断，后、车、象都是射线判断。             每种情况，调用不同的方向向量即可。 说明：没有同时成立的情
UVA 10196 - Check The Check (将军)
Cyibing的专栏
09-29 1220
UVA 10196 - Check The Check (将军) 题目描述 * 模拟棋盘。黑棋在棋盘的上半部分，用小写字母表示；白棋在下半部分，用大写字母表示。 * 一共有六种棋子。 * p ——> 只能走斜前方。即白棋只能走↖（左上），↗（右上）；黑棋只能走↙（左下），↘（右下） * r ——> 可以走垂直方向和水平方向上走，可以走任意格。 * b ——> 可以走对角线方向上走，可以走任意格。 * q ——> 可以走垂直方向、水平方向、对角线方向，可以走任意格。 * k ——> 可以走垂直方向、水平方向
UVa 10196 - Check The Check （模拟）
cc_again的专栏
12-07 1193
题目链接： http://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=1137   题目大意： 给你一副国际象棋的格局，让你判断哪方被将军了。   解题思路： 模拟题，考虑每方每一颗棋子的对另一方的攻击范围，如果对方王在某一颗棋子的攻击范围内，则对方被将
UVa Problem 10196 Check the Check （将军）
peizhiinfo
05-19 110
// Check the Check （将军） // PC/UVa IDs: 110107/10196, Popularity: B, Success rate: average Level: 1 // Verdict: Accepted // Submission Date: 2011-05-22 // UVa Run Time: 0.008s // // 版权所有（C）2011，邱秋。meta...
UVA11743 Credit Check【数学计算】
海岛Blog
03-24 339
These days, it has become commonplace to make purchases over the internet using a credit card. However, because credit card numbers are relatively long, it is easy to make a mistake while typing them in. In order to quickly identify errors like typos, most
Uva 101 the block problem 木块问题（算法竞赛经典入门）STL vector
因你是玫瑰色的你
05-06 7502
Uva 101 the block problem 木块问题 题目大意： 输入n，得到编号为0~n-1的木块，分别摆放在顺序排列编号为0~n-1的位置。现对这些木块进行操作，操作分为四种。 1、move a onto b：把木块a、b上的木块放回各自的原位，再把a放到b上； 2、move a over b：把a上的木块放回各自的原位，再把a发到含b的堆上； 3、p
UVA 1589 象棋
u012861792的博客
08-22 314
这道题简直是太坑了。一开始在本机上测试怎么都对，但是提交之后无论如何都过不了，简直是要绝望。到最后尝试了一下把%c+getchar()换成了%s之后，终于成功AC。太坑了…………………… #include&amp;amp;amp;lt;cstdio&amp;amp;amp;gt; #include&amp;amp;amp;lt;cstring&amp;amp;amp;gt; using namespace std; int boom[11][11],p[11][11];
UVA11624-Fire!（BFS+预处理）
Stark_industry
03-07 254
题目链接：传送门Biubiubiu~~~ 吐槽一下这道题，做题体验极差，在uva转都转不了，在vjudge上也是要么提交失败要么就在队列中不动了，而且这题还挖了大坑，真的是折磨了我几天，打了几次，多少次过了样例就是不知道错哪里mdzz… 分析：题意大概是joe要逃离迷宫，同时迷宫着火，逃离成功的标志是Joe达到任意一条边界，而火焰回向四处燃烧并且持续不断向四周燃烧，这么一看就是两个BFS，然而却不...
qt5-qtcanvas3d-5.12.5-3.el8.tar.gz
08-19
# 适用操作系统：Centos8 #Step1、解压 tar -zxvf xxx.el8.tar.gz #Step2、进入解压后的目录，执行安装 sudo rpm -ivh *.rpm
sox-14.4.2.0-29.el8.tar.gz
08-19
# 适用操作系统：Centos8 #Step1、解压 tar -zxvf xxx.el8.tar.gz #Step2、进入解压后的目录，执行安装 sudo rpm -ivh *.rpm
【直流微电网】基于预设性能控制的DC/DC升压转换器复合控制策略设计：稳定恒功率负载电压跟踪（含详细代码及解释）
08-19
内容概要：本文围绕直流微电网中带有恒功率负载(CPL)的DC/DC升压转换器的稳定控制问题展开研究，提出了一种复合预设性能控制策略。首先，通过精确反馈线性化技术将非线性不确定的DC转换器系统转化为Brunovsky标准型，然后利用非线性扰动观测器评估负载功率的动态变化和输出电压的调节精度。基于反步设计方法，设计了具有预设性能的复合非线性控制器，确保输出电压跟踪误差始终在预定义误差范围内。文章还对比了多种DC/DC转换器控制技术如脉冲调整技术、反馈线性化、滑模控制(SMC)、主动阻尼法和基于无源性的控制，并分析了它们的优缺点。最后，通过数值仿真验证了所提控制器的有效性和优越性。 适合人群：从事电力电子、自动控制领域研究的学者和工程师，以及对先进控制算法感兴趣的研究生及以上学历人员。 使用场景及目标：①适用于需要精确控制输出电压并处理恒功率负载的应用场景；②旨在实现快速稳定的电压跟踪，同时保证系统的鲁棒性和抗干扰能力；③为DC微电网中的功率转换系统提供兼顾瞬态性能和稳态精度的解决方案。 其他说明：文中不仅提供了详细的理论推导和算法实现，还通过Python代码演示了控制策略的具体实现过程，便于读者理解和实践。此外，文章还讨论了不同控制方法的特点和适用范围，为实际工程项目提供了有价值的参考。
光学成像基于偏振敏感强度衍射断层扫描的三维各向异性成像技术研究：PS-IDT在复杂散射样品中的应用与优化（含详细代码及解释）
最新发布
08-19
内容概要：该论文介绍了一种名为偏振敏感强度衍射断层扫描（PS-IDT）的新型无参考三维偏振敏感计算成像技术。PS-IDT通过多角度圆偏振光照射样品，利用矢量多层光束传播模型（MSBP）和梯度下降算法迭代重建样品的三维各向异性分布。该技术无需干涉参考光或机械扫描，能够处理多重散射样品，并通过强度测量实现3D成像。文中展示了对马铃薯淀粉颗粒和缓步类动物等样品的成功成像实验，并提供了Python代码实现，包括系统初始化、前向传播、多层传播、重建算法以及数字体模验证等模块。 适用人群：具备一定光学成像和编程基础的研究人员，尤其是从事生物医学成像、材料科学成像领域的科研工作者。 使用场景及目标：①研究复杂散射样品（如生物组织、复合材料）的三维各向异性结构；②开发新型偏振敏感成像系统，提高成像分辨率和对比度；③验证和优化计算成像算法，应用于实际样品的高精度成像。 其他说明：PS-IDT技术相比传统偏振成像方法具有明显优势，如无需干涉装置、无需机械扫描、可处理多重散射等。然而，该技术也面临计算复杂度高、需要多角度数据采集等挑战。文中还提出了改进方向，如采用更高数值孔径（NA）物镜、引入深度学习超分辨率技术等，以进一步提升成像质量和效率。此外，文中提供的Python代码框架为研究人员提供了实用的工具，便于理解和应用该技术。
qt5-qtdeclarative-5.15.2-2.el8.tar.gz
08-19
# 适用操作系统：Centos8 #Step1、解压 tar -zxvf xxx.el8.tar.gz #Step2、进入解压后的目录，执行安装 sudo rpm -ivh *.rpm
UVA题库AC代码大全解析
标题和描述中提到的“uva最全ac代码”可能是指关于UVa Online Judge（通常简称为UVa）这个在线编程训练平台上的AC（Accepted）代码集。UVa Online Judge是一个面向编程爱好者的在线判题系统，它提供了大量的编程问题...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值