POJ 3765 Xiang Hex【暴力模拟】

最新推荐文章于 2018-10-13 21:39:53 发布
最新推荐文章于 2018-10-13 21:39:53 发布
阅读量954 收藏
点赞数
分类专栏： 暴力枚举 文章标签： POJ 3765 PKU 3765
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mengxiang000000/article/details/51106289
版权

Xiang Hex
Time Limit: 1000MS Memory Limit: 65536K
Total Submissions: 985 Accepted: 509

Description

Xiang Hex is Chinese Chess played upon an elongated hexagonal field, consisting of nine files with the outer ones being seven cells and the center being eleven. The "palace" consists of seven cells, the first three cells of the center file and the first two cells which flank. The "river" is denoted by fourth cell of the first and ninth file, the fifth cell of the third and seventh file and the sixth cell of the center file. The player's side of the field consists of the cells before the "river".

If you know how to play Chess, the rules of Xiang Hex will be familiar. The general idea is the same. Each player controls an army (red or black) of pieces, moves one piece at a time, and tries to get the opponent's royal piece.

You can see the "palace" and the "river" below: ("r" is the "river", "P" is the "palace" of red army, and "p" is the "palace" of black army)


 

Each file was marked from the left to the right with an uppercase character A, B ... I, and the location of a hexagonal can be expressed by the character of the file and the number of hexagonal under it in the same file (No space between the character and the number).

There are seven kinds of pieces in Xiang Hex:

  1. SOLDIER(S) step one forward orthogonal before entering the "river". Upon and after entering the "river" step one forward, right forward or left forward orthogonal, or right or left diagonal.
  2. HORSE(H) step one vacant orthogonal then one diagonal in the same direction.
  3. CHARIOT(C) slide orthogonal.
  4. CANNON(A) slide orthogonal through vacant cells, may leap any one piece to capture an enemy.
  5. ELEPHANT(E) step two diagonal and never cross the "river".
  6. MANDARIN(M) step diagonal and never leave the "palace"
  7. GENERAL(G) step orthogonal and never leave the "palace". Not permitted be on an empty file with the opposing GENERAL.

And this is the setup of Xiang Hex: (Lowercase pieces belong to black army and uppercase pieces belong to red army)


The game is won by checkmating the opposing GENERAL. A player loses if stalemate or repetition of position. If both players have no pieces which can cross the "river", the game is drawn.

Recently, the Association of Chess Men (ACM) wants to hold a competition of Xiang Hex. However, they don't know how to display the current board in real-time during the games. Now they ask you for help.

Input

There are several test cases in the input. The first line of each case contains an integer n, the number of pieces on the board. The following n lines, each line contains the location of the pieces and a character indicates the type of the pieces. The input is ended by n = 0.

Output

Just display the board as the sample. Extra space at the end of line is not allowed.

Sample Input

11
E10 g
C8 e
E9 m
B6 C
I5 s
H5 a
D5 h
C4 S
A1 S
E1 G
H1 A
0

Sample Output

         _
       _/g\_
     _/ \_/ \_
   _/e\_/m\_/ \_
 _/ \_/ \_/ \_/ \_
/ \_/ \_/ \_/ \_/ \
\_/C\_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/s\
\_/ \_/ \_/ \_/a\_/
/ \_/ \_/ \_/ \_/ \
\_/ \_/h\_/ \_/ \_/
/ \_/S\_/ \_/ \_/ \
\_/ \_/ \_/ \_/ \_/
/ \_/ \_/ \_/ \_/ \
\_/ \_/ \_/ \_/ \_/
/S\_/ \_/ \_/ \_/ \
\_/ \_/ \_/ \_/A\_/
/ \_/ \_/ \_/ \_/ \
\_/ \_/ \_/ \_/ \_/
  \_/ \_/G\_/ \_/
    \_/ \_/ \_/
      \_/ \_/
        \_/
 

题目大意：

给你一个蜂窝槽一样的一个基础图，然后在上边摆棋子，

思路：慢慢的，一步一步的，一点一点的，仔仔细细的，打图：

void init()
{
    memset(output,' ',sizeof(output));
        output[0][9]='_';
        output[1][8]='/';output[1][10]='\\';
        output[1][7]='_';output[1][11]='_';
        output[2][5]='_';output[2][6]='/';output[2][7]=' ';output[2][8]='\\';output[2][9]='_';output[2][10]='/';output[2][11]=' ';output[2][12]='\\';output[2][13]='_';
        output[3][3]='_';output[3][4]='/';output[3][5]=' ';output[3][6]='\\';output[3][7]='_';output[3][8]='/';output[3][9]=' ';output[3][10]='\\';output[3][11]='_';output[3][12]='/';output[3][13]=' ';output[3][14]='\\';output[3][15]='_';
        output[4][1]='_';output[4][2]='/';output[4][3]=' ';output[4][4]='\\';output[4][5]='_';output[4][6]='/';output[4][7]=' ';output[4][8]='\\';output[4][9]='_';output[4][10]='/';output[4][11]=' ';output[4][12]='\\';output[4][13]='_';output[4][14]='/';output[4][15]=' ';output[4][16]='\\';output[4][17]='_';
        output[5][0]='/';output[5][1]=' ';output[5][2]='\\';output[5][3]='_';output[5][4]='/';output[5][5]=' ';output[5][6]='\\';output[5][7]='_';output[5][8]='/';output[5][9]=' ';output[5][10]='\\';output[5][11]='_';output[5][12]='/';output[5][13]=' ';output[5][14]='\\';output[5][15]='_';output[5][16]='/';output[5][17]=' ';output[5][18]='\\';
        output[6][0]='\\';output[6][1]='_';output[6][2]='/';output[6][3]=' ';output[6][4]='\\';output[6][5]='_';output[6][6]='/';output[6][7]=' ';output[6][8]='\\';output[6][9]='_';output[6][10]='/';output[6][11]=' ';output[6][12]='\\';output[6][13]='_';output[6][14]='/';output[6][15]=' ';output[6][16]='\\';output[6][17]='_';output[6][18]='/';
        for(int i=7;i<=18;i++)
        {
            if(i%2==1)
            {
                for(int j=0;j<30;j++)
                {
                    output[i][j]=output[5][j];
                }
            }
            else
            {
                for(int j=0;j<30;j++)
                {
                    output[i][j]=output[6][j];
                }
            }
        }
        output[19][2]='\\';output[19][3]='_';output[19][4]='/';output[19][5]=' ';output[19][6]='\\';output[19][7]='_';output[19][8]='/';output[19][9]=' ';output[19][10]='\\';output[19][11]='_';output[19][12]='/';output[19][13]=' ';output[19][14]='\\';output[19][15]='_';output[19][16]='/';
        output[20][4]='\\';output[20][5]='_';output[20][6]='/';output[20][7]=' ';output[20][8]='\\';output[20][9]='_';output[20][10]='/';output[20][11]=' ';output[20][12]='\\';output[20][13]='_';output[20][14]='/';
        output[21][6]='\\';output[21][7]='_';output[21][8]='/';output[21][9]=' ';output[21][10]='\\';output[21][11]='_';output[21][12]='/';
        output[22][8]='\\';output[22][9]='_';output[22][10]='/';
}
然后分析当列是E的时候，当列是C/F的时候，当列是B/G的时候，当列是A/I的时候，行上边该确定的位子，和列上边控制的位子。

仔仔细细的判断完，我们就可以开开心心的AC啦~~~~~~~~~~

AC代码：

#include<stdio.h>
#include<string.h>
using namespace std;
char output[30][30];
void init()
{
    memset(output,' ',sizeof(output));
        output[0][9]='_';
        output[1][8]='/';output[1][10]='\\';
        output[1][7]='_';output[1][11]='_';
        output[2][5]='_';output[2][6]='/';output[2][7]=' ';output[2][8]='\\';output[2][9]='_';output[2][10]='/';output[2][11]=' ';output[2][12]='\\';output[2][13]='_';
        output[3][3]='_';output[3][4]='/';output[3][5]=' ';output[3][6]='\\';output[3][7]='_';output[3][8]='/';output[3][9]=' ';output[3][10]='\\';output[3][11]='_';output[3][12]='/';output[3][13]=' ';output[3][14]='\\';output[3][15]='_';
        output[4][1]='_';output[4][2]='/';output[4][3]=' ';output[4][4]='\\';output[4][5]='_';output[4][6]='/';output[4][7]=' ';output[4][8]='\\';output[4][9]='_';output[4][10]='/';output[4][11]=' ';output[4][12]='\\';output[4][13]='_';output[4][14]='/';output[4][15]=' ';output[4][16]='\\';output[4][17]='_';
        output[5][0]='/';output[5][1]=' ';output[5][2]='\\';output[5][3]='_';output[5][4]='/';output[5][5]=' ';output[5][6]='\\';output[5][7]='_';output[5][8]='/';output[5][9]=' ';output[5][10]='\\';output[5][11]='_';output[5][12]='/';output[5][13]=' ';output[5][14]='\\';output[5][15]='_';output[5][16]='/';output[5][17]=' ';output[5][18]='\\';
        output[6][0]='\\';output[6][1]='_';output[6][2]='/';output[6][3]=' ';output[6][4]='\\';output[6][5]='_';output[6][6]='/';output[6][7]=' ';output[6][8]='\\';output[6][9]='_';output[6][10]='/';output[6][11]=' ';output[6][12]='\\';output[6][13]='_';output[6][14]='/';output[6][15]=' ';output[6][16]='\\';output[6][17]='_';output[6][18]='/';
        for(int i=7;i<=18;i++)
        {
            if(i%2==1)
            {
                for(int j=0;j<30;j++)
                {
                    output[i][j]=output[5][j];
                }
            }
            else
            {
                for(int j=0;j<30;j++)
                {
                    output[i][j]=output[6][j];
                }
            }
        }
        output[19][2]='\\';output[19][3]='_';output[19][4]='/';output[19][5]=' ';output[19][6]='\\';output[19][7]='_';output[19][8]='/';output[19][9]=' ';output[19][10]='\\';output[19][11]='_';output[19][12]='/';output[19][13]=' ';output[19][14]='\\';output[19][15]='_';output[19][16]='/';
        output[20][4]='\\';output[20][5]='_';output[20][6]='/';output[20][7]=' ';output[20][8]='\\';output[20][9]='_';output[20][10]='/';output[20][11]=' ';output[20][12]='\\';output[20][13]='_';output[20][14]='/';
        output[21][6]='\\';output[21][7]='_';output[21][8]='/';output[21][9]=' ';output[21][10]='\\';output[21][11]='_';output[21][12]='/';
        output[22][8]='\\';output[22][9]='_';output[22][10]='/';
}
int main()
{
    int n;
    while(~scanf("%d",&n))
    {
        if(n==0)break;
        init();
        for(int i=0;i<n;i++)
        {
            char str[15];char p;
            scanf("%s %c",str,&p);
            int lie=str[0]-'A'+1;
            int hang=0;
            int cont=1;
            for(int i=strlen(str)-1;i>=1;i--)
            {
                hang=cont*(str[i]-'0');
                cont*=10;
            }
            if(str[0]=='E')
            {
                hang=(10-hang)*2+1;
            }
            if(str[0]=='D'||str[0]=='F')
            {
                hang=(10-hang)*2;
            }
            if(str[0]=='C'||str[0]=='G')
            {
                hang=(9-hang)*2+1;
            }
            if(str[0]=='B'||str[0]=='H')
            {
                hang=(9-hang)*2;
            }
            if(str[0]=='A'||str[0]=='I')
            {
                hang=(8-hang)*2+1;
            }
            int zhenshilie=lie*2-1;
            output[hang][zhenshilie]=p;
            //printf("%d %d\n",zhenshilie-1,(10-hang)*2+1);
        }
        /*
      for(int i=0;i<23;i++)
      {
          for(int j=0;j<19;j++)
          {
              printf("%c",output[i][j]);
          }
          printf("\n");
      }*/
        for(int i=0;i<=4;i++)
        {
            for(int j=0;j<10+2*i;j++)
            {
                printf("%c",output[i][j]);
            }
            printf("\n");
        }
        for(int i=5;i<19;i++)
        {
            for(int j=0;j<19;j++)
            {
                printf("%c",output[i][j]);
            }
            printf("\n");
        }
        for(int i=19;i<=22;i++)
        {
            int tmp=i-19;
            for(int j=0;j<16-tmp*2+1;j++)
            {
                printf("%c",output[i][j]);
            }
            printf("\n");
        }
    }
}








mengxiang000000
关注
专栏目录
Poj1379模拟退火
06-18
poj1379 给予平面内一个点集； 使用模拟退火求出一个点使该点到上述点集内任意一点最短距离最长。
POJ 3765 Xiang Hex
九野的博客
08-19 1917
模拟题 题意：在如图中的蜂窝中，填上给定坐标的字母   #include #include char map[21][10]; int main(){ int i,a,n,j; while(scanf("%d",&n),n) { for(i=0;i<21;i++) for(j=0;j<10;j++) map[i][j]=' '; while
POJ 3765 Xiang Hex G++
woniupengpeng的专栏
02-14 259
#include #include #include #include using namespace std; int main() { vector gg; vector str; vector jj; while(1) { int NUM; cin>>NUM; if(NUM==0) { break; } gg.push_back(NUM);
poj_3765_Xiang Hex
Kamy Shi
04-10 986
题目：http://poj.org/problem?id=3765 这个题目是我们一次比赛的题目，看着挺简单的，呵呵，只要你看懂题目就行了，废话不多说。 代码贴上，大家参考下，不懂给我留言。欢迎交流！ #include #include #include using namespace std; int main() { string str[23]; str[0]= "
Xiang Hex【暴力模拟】
几许情愁的博客
10-13 249
Xiang Hex Time Limit: 1000MS         Memory Limit: 65536K Total Submissions: 985         Accepted: 509 Description Xiang Hex is Chinese Chess played upon an elongated hexagonal field, consisting of n...
2015 ACM/ICPC 北京区域赛 现场赛 D—Kejin Game【最大流】
lml11111的博客
10-01 436
http://media.hihocoder.com/contests/icpcbeijing2015/problems.pdf 题意： 题意：给一颗有向树，技能获得的前提是他的前置技能都获得了，作为一个玩家，你有特权： 1.直接花费一定数量的钱获得某个技能。 2.花费一定数量的钱将一个技能的某一个前置关系取消，即将前置技能到该技能的边消除（不需要获得前置技能）。 如果正常学习技能...
poj1363 Rails(栈模拟)
苏苏爱自由
05-13 5999
D - Rails Crawling in process... Crawling failed Time Limit:1000MS     Memory Limit:10000KB     64bit IO Format:%I64d & %I64u Submit Status Practice POJ 1363 Appoint description:
POJ 1750 Dictionary（模拟）
09-12 1760
POJ 1750 Dictionary（模拟）
POJ 2531 Network Saboteur 暴力
要做ADC
08-08 9442
Network Saboteur Time Limit: 2000MS   Memory Limit: 65536K Total Submissions: 11392   Accepted: 5513 Description A university network is composed of N computers. System a
POJ.rar_poj java_poj1048
09-24
【标题】"POJ.rar_poj java_poj1048" 涉及的知识点主要围绕编程竞赛中的“约瑟夫环”问题，这里是一个加强版，使用Java语言进行解决。 【描述】"POJ1048，加强版的约瑟夫问题 难度中等" 提示我们，这个问题是编程...
POJ_3131.zip_POJ 八数码_poj
09-20
标题中的“POJ_3131.zip_POJ 八数码_poj”指的是一个与编程竞赛网站POJ（Problem Set Algorithm）相关的项目，具体是针对3131号问题的解决方案，该问题涉及到了八数码游戏。八数码游戏，又称滑动拼图，是一个经典的...
poj2775.rar_poj_poj 27_poj27_poj2775
09-23
标签"poj poj_27 poj27 poj2775"进一步确认了这是一道关于POJ平台的编程挑战，其中"poj_27"可能是表示第27类问题或者某种分类，而"poj27"可能是对"poj2775"的简写。 压缩文件中的"www.pudn.com.txt"可能是一个链接...
poj.rar_poj
09-23
标题中的"poj.rar_poj"暗示了这是一个与POJ（Programming Online Judge）相关的压缩文件，POJ是一个在线编程竞赛平台，主要供程序员们练习和提交算法解决方案。在这个压缩包中，很可能包含了用户在POJ上参与编程挑战...
c#实现俄罗斯方块，面向对象实现
09-15
俄罗斯方块（Tetris）是一款经典的益智游戏，由俄罗斯程序员阿列克谢·帕基特诺夫于1984年开发。游戏的主要目标是通过旋转和移动不同形状的方块（称为“砖块”或“Tetrominoes”），将它们填充到屏幕底部的水平行中。当一行被完全填满时，该行会消失，玩家将获得积分。 游戏特点： 砖块形状：游戏中有七种不同形状的砖块，每种砖块由四个方块组成。 下落机制：砖块从屏幕顶部逐渐下落，玩家需要快速做出决策。 得分系统：消除的行越多，得分越高，连续消除多行会获得额外分数。 难度递增：随着游戏进行，砖块下落的速度会逐渐加快，增加了游戏的挑战性。 文化影响： 俄罗斯方块不仅在游戏界取得了巨大的成功，还成为了流行文化的一部分，影响了许多后续的游戏设计。它的简单性和上瘾性使其成为了历史上最畅销的电子游戏之一。 版本与平台： 自发布以来，俄罗斯方块已经在多个平台上推出，包括家用游戏机、电脑、手机等，形成了众多不同的版本和变种。
5G网络优化案例：关于解决诺基亚5G 700M站点小区闪断问题解决.pdf
09-15
这份文件是关于解决诺基亚5G 700M站点小区闪断问题的详细案例报告，主要内容和关键要点如下： 问题背景与初步分析： 问题描述：随着5G 700M网络建设的推进，诺基亚700M现网出现较多误码告警和小区闪断问题，故障比例明显高于其他厂家站点。 初步定位：通过归类法分析，发现绝大部分误码问题发生在烽火单芯双向光模块小区，占比高达95.65%。 故障根因深入探究： 光模块适配问题：初步认为烽火单纤双向光模块存在问题，但更换后问题依旧，进一步分析为光模块与诺基亚设备的适配问题。 深入测试与定位：选取5个长期误码小区进行深入分析，与烽火厂家合作对光模块进行程序升级，问题得到初步解决。 AUTOBYPASS机制分析： 机制介绍：烽火光模块采用25G模块速率兼容10G，并开启AUTOBYPASS（CPR自动旁路模式）功能。 影响分析：AUTOBYPASS机制与诺基亚设备不适配，导致交互失败和误码产生。关闭AUTOBYPASS后，CDR时钟校验和恢复周期缩短，交互频繁，误码问题消失。 解决方案与实施： 解决方案：针对所有使用此类光模块的诺基亚站点，通过优化升级烽火光模块，关闭AUTOBYPASS功
在线请假管理系统.zip
09-15
这是一个基于Python Flask的Web应用程序，采用Bulma uI框架和Postgresql数据库，用于管理和处理员工的请假事宜。用户可以通过这个系统创建安全的用户账户并登录，员工可以提交请假申请等待上级审批，并查看历史请假记录。经理可以审批或拒绝员工的请假申请，并查看团队的请假记录。此外，管理员还可以查看所有员工信息，添加新员工并分配经理，编辑和删除员工信息。该项目在heroku上托管，提供在线服务。安装步骤包括克隆项目、创建虚拟环境、激活环境并安装依赖项等。还提供了数据库迁移和初始化、运行应用程序以及数据重置等实用工具命令。 1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.文md件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。
performance-timing.js利用HTML5的navigation_timing_API_performance
最新发布
09-15
performance-timing.js利用HTML5的navigation_timing_API_performance-timing
ssm+mysql的小说阅读网站书城（源码+lw+ppt）
09-15
内容概要： 基于SSM框架、Java语言和MySQL数据库的小说网站。系统旨在为用户提供一个在线阅读和搜索小说的平台，支持用户注册、小说列表查看、在线支付和排行榜等功能。系统采用B/S架构，前端使用JS语言进行界面设计，后端通过SSM框架进行开发。 适用人群： 本系统适用于广大网络小说读者、作者和出版社。 使用场景及目标： 1. 读者可以通过系统在线阅读小说，搜索自己喜欢的作品。 2. 作者可以上传自己的作品，与读者互动。 3. 出版社可以通过系统发布和管理小说资源。 其它说明： 系统设计考虑了用户友好性和操作便捷性，通过技术手段确保数据安全性。系统具备良好的扩展性，可适应未来功能升级需求。通过本系统，用户可以方便地获取所需小说资源，同时作者和出版社也能有效地管理自己的作品。 关键词：小说网站；MYSQL数据库；SSM框架；JS技术
8.zabbix构建企业级监控告警平台(1).学习笔记整理分享给需要的同学
09-15
8.zabbix构建企业级监控告警平台(1).学习笔记整理分享给需要的同学
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值