UVa 1589 da模拟！！

最新推荐文章于 2022-10-11 17:42:42 发布
最新推荐文章于 2022-10-11 17:42:42 发布
阅读量1k 收藏
点赞数
分类专栏： ACM_模拟 文章标签： UVa C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jibancanyang/article/details/43129205
版权

背景:1_WA:忘了把用来检测bug的中间结果输出注释！！

2_WA：各种小错，外加输出处，下标错误！！！！！

3_WA:逻辑错误上的，不自己出数据，并输出中间结果，真是很难发现！

4_WA:俥和帅见面的考虑都错了！！！！！！！如果中间有棋子挡着，俥是不能通过的！！！！帅也是不能见面的！！幸好乱写的测试数据发现了这个！！！

567_WA:结果！已经毫无逻辑错误了！！无奈搜索了解题报告，原来不能用scanf，要用cin!

思路：网上好的思路是把黑方帅下一步要走的位置的所有情况求出来，对每一种情况进行枚举，看是否有红方棋子可以到达该位置。我的思路：是把所有红方可以杀死的位置的出来，看黑将是否可以走到红方无法杀死的位置，但其中的各种讨论着实费心！！

学习：1.#include<iostream> 下的cin来输入，可以略掉空格，TAB，换行符等！

2.自己多出数据！写代码前应该先建立思路！

3.sprintf函数将数字等读入到字符数组中。

char str[30];
int a,b;
sprintf(str,"%d is %d",a,b);


#include<stdio.h>
#include<iostream>
#include<cstdio>
#include<string.h>
using namespace std;
int map[10][9],count=0;
struct place{
	int x;
	int y;
}green,ans[1000];

void print(void){
	  while(1){
          if(green.x-1 > 0 && map[green.x-2][green.y-1] != 1 && map[green.x-2][green.y-1] != 9){printf("NO\n"); break;}
          if(green.x+1 < 4 && map[green.x][green.y-1] != 1 && map[green.x][green.y-1] != 9){printf("NO\n"); break;}
          if(green.y-1 > 3 && map[green.x-1][green.y-2]!= 1 && map[green.x-1][green.y-2] != 9) {printf("NO\n"); break;}
          if(green.y+1 < 7 && map[green.x-1][green.y] != 1 && map[green.x-1][green.y] != 9){printf("NO\n"); break;}
          printf("YES\n"); break;
		}
} 
 
void RR(void){
	  for(int i=0;i < 10;i++){
	  	  for(int j=0;j < 9;j++){
	  	  	  if(map[i][j] == 2){
	  	  	  	  for(int k=j+1; k < 9;k++){
	  	  	  	  	  if(!(map[i][k] == 0 || map[i][k] == 1)){
	  	  	  	  	  	  ans[count].x=i;
	  	  	  	  	  	  ans[count++].y=k;
	  	  	  	  	  	  break;
	  	  	  	  	  }
	  	  	  	  	  if(map[i][k] == 0 || map [i][k] == 1) map[i][k]=1;  	  
	  	  	  	  }
	  	  	  	  for(int k=j-1; k >= 0;k--){
	  	  	  	  	  if(!(map[i][k] == 0 || map[i][k] == 1)){
	  	  	  	  	  	  ans[count].x=i;
	  	  	  	  	  	  ans[count++].y=k;
	  	  	  	  	  	  break;
	  	  	  	  	  }
	  	  	  	  	  if(map[i][k] == 0 || map [i][k] == 1) map[i][k]=1;
	  	  	  	  }
	  	  	  	  for(int k=i-1; k >= 0;k--){
	  	  	  	  	  if(!(map[k][j] == 0 || map[k][j] == 1)){
	  	  	  	  	  	  ans[count].x=k;
	  	  	  	  	  	  ans[count++].y=j;
	  	  	  	  	  	  break;
	  	  	  	  	  }
	  	  	  	  	  if(map[k][j] == 0 || map [k][j] == 1) map[k][j]=1;
	  	  	  	  }
	  	  	  	  for(int k=i+1; k < 10;k++){
	  	  	  	  	  if(!(map[k][j] == 0 || map[k][j] == 1)){
	  	  	  	  	  	  ans[count].x=k;
	  	  	  	  	  	  ans[count++].y=j;
	  	  	  	  	  	  break;
	  	  	  	  	  }
	  	  	  	  	  if(map[k][j] == 0 || map [k][j] == 1) map[k][j]=1;
	  	  	  	  }
	  	  	  }
	  	  }
	  }
}

void horse(void){
        for(int i=0;i < 10;i++){
            for(int j=0;j < 9;j++){
                if(map[i][j] == 3){
                    if(map[i+1][j] == 1 || map[i+1][j] == 0){
                        if(i+2 < 10 ){
                            if(j+1 < 9){
														    if(map[i+2][j+1] == 0) map[i+2][j+1]=1;
														    else if(map[i+2][j+1] != 1){
														    	  ans[count].x=i+2;
														    	  ans[count++].y=j+1;
														    } 
													  }
                            if(j-1 >= 0){
																if(map[i+2][j-1] == 0) map[i+2][j-1]=1;
														    else if(map[i+2][j-1] != 1){
														    	  ans[count].x=i+2;
														    	  ans[count++].y=j-1;
														    } 
                            }
                        }
                    }
                    if(map[i-1][j] == 1 || map[i-1][j] == 0){
                        if(i-2 >= 0 ){
                            if(j+1 < 9){
                            	  if(map[i-2][j+1] == 0) map[i-2][j+1]=1;
														    else if(map[i-2][j+1] != 1){
														    	  ans[count].x=i-2;
														    	  ans[count++].y=j+1;
														    } 
                            }
                            if(j-1 >= 0){
																if(map[i-2][j-1] == 0) map[i-2][j-1]=1;
														    else if(map[i-2][j-1] != 1){
														    	  ans[count].x=i-2;
														    	  ans[count++].y=j-1;
														    } 
                            }
                        }
                    }
                    if(map[i][j+1] == 1 || map[i][j+1] == 0){
                        if(j+2 < 9 ){
                            if(i+1 < 10){
                            	  if(map[i+1][j+2] == 0) map[i+1][j+2]=1;
														    else if(map[i+1][j+2] != 1){
														    	  ans[count].x=i+1;
														    	  ans[count++].y=j+2;
														    } 
                            }
                            if(i-1 >= 0){
                            	  if(map[i-1][j+2] == 0) map[i-1][j+2]=1;
														    else if(map[i-1][j+2] != 1){
														    	  ans[count].x=i-1;
														    	  ans[count++].y=j+2;
														    } 
                            }
                        }
                    }
                    if(map[i][j-1] == 1 || map[i][j-1] == 0){
                        if(j-2 >= 0){
                            if(i+1 < 10){
                            	  if(map[i+1][j-2] == 0) map[i+1][j-2]=1;
														    else if(map[i+1][j-2] != 1){
														    	  ans[count].x=i+1;
														    	  ans[count++].y=j-2;
														    } 
                            }
                            if(i-1 >= 0){
																if(map[i-1][j-2] == 0) map[i-1][j-2]=1;
														    else if(map[i-1][j-2] != 1){
														    	  ans[count].x=i-1;
														    	  ans[count++].y=j-2;
														    } 
                            }
                        }
                    }
                }

            }
        }
}

void cannon(void){
    for(int i=0;i < 10;i++){
        for(int j=0;j < 9;j++){
            if(map[i][j] == 4){
                bool key=true;
                for(int k=i-1;k >= 0;k--){
                    if(key){if(!(map[k][j] == 0 || map[k][j] ==1)) key=false;} 
                    else{
                        if(map[k][j] == 0) map[k][j]=1;
                        else if(map[k][j] != 1){
														    	  ans[count].x=k;
														    	  ans[count++].y=j;
														    	  break;
												} 
                    }
                }
                key=true;
                for(int k=i+1;k < 10;k++){
                    if(key){if(!(map[k][j] == 0 || map[k][j] ==1)) key=false;} 
                    else{
                        if(map[k][j] == 0) map[k][j]=1;
                        else if(map[k][j] != 1){
														    	  ans[count].x=k;
														    	  ans[count++].y=j;
														    	  break;
												} 
                    }
                }
                key=true;
                for(int k=j+1;k < 9;k++){
                    if(key){if(!(map[i][k] == 0 || map[i][k] ==1)) key=false;} 
                    else{
                        if(map[i][k] == 0) map[i][k]=1;
                        else if(map[i][k] != 1){
														    	  ans[count].x=i;
														    	  ans[count++].y=k;
														    	  break;
												} 
                    }
                }
                key=true;
                for(int k=j-1;k >= 0;k--){
                    if(key){if(!(map[i][k] == 0 || map[i][k] ==1)) key=false;} 
                    else{
                        if(map[i][k] == 0) map[i][k]=1;
                        else if(map[i][k] != 1){
														    	  ans[count].x=i;
														    	  ans[count++].y=k;
														    	  break;
												} 
                    }
                }
            }
        }
    }
}

void GG(void){
	  for(int i=0;i < 10;i++){
	  	  for(int j=0;j < 9;j++){
	  	  	  if(map[i][j] == 5){
	  	  	  	  for(int k=i-1;k >= 0;k--){
	  	  	  	  	  if(!(map[k][j] == 0 || map[k][j] == 1)){
	  	  	  	  	  	  ans[count].x=k;
	  	  	  	  	  	  ans[count++].y=j;
	  	  	  	  	  	  break;
	  	  	  	  	  }
	  	  	  	  	  if(map[k][j] == 0 || map [k][j] == 1) map[k][j]=1;
	  	  	  	  }
	  	  	  	  for(int k=i+1;k < 10;k++){
	  	  	  	  	  if(!(map[k][j] == 0 || map[k][j] == 1)){
	  	  	  	  	  	  ans[count].x=k;
	  	  	  	  	  	  ans[count++].y=j;
	  	  	  	  	  	  break;
	  	  	  	  	  }
	  	  	  	  	  if(map[k][j] == 0 || map [k][j] == 1) map[k][j]=1;
	  	  	  	  }
	  	  	  	  return;
	  	  	  }
	  	  }
	  }
}

void step(void){
	char c;
	int m,n;
  cin>>c>>m>>n;    //ÔÚ»º³åÇøÓÐÒ»¸ö»»Ðзû¡£ 
	//scanf("%c",&c);
	if(c == 'R'){
        //scanf("%d%d",&m,&n);
        if(map[m-1][n-1] == 1){
        	ans[count].x=m-1;
        	ans[count++].y=n-1;
        }
        map[m-1][n-1]=2;
	}
	else if( c == 'H'){
        //scanf("%d%d",&m,&n);
        if(map[m-1][n-1] == 1){
        	ans[count].x=m-1;
        	ans[count++].y=n-1;
        } 
        map[m-1][n-1]=3;  
        
	}
	else if( c == 'C'){
        //scanf("%d%d",&m,&n);
        if(map[m-1][n-1] == 1){
        	ans[count].x=m-1;
        	ans[count++].y=n-1;
        }         
        map[m-1][n-1]=4;
	}
	else{
		    //scanf("%d%d",&m,&n);
        map[m-1][n-1]=5;    //ºì·½Ë§¾ÍÔÚÀÏÎÑÀ¸ù±¾Ã»ÓбØÒª±ê¼ÇΪ9¡£ 
	}
}

int main(void){
		int a;
		while(cin>>a>>green.x>>green.y && a != 0){
			count=0;
			memset(map,0,sizeof(map));
			while(a--){
				step();
			}
/**///			for(int i=0;i < 10;i++){for(int j=0;j < 9;j++) printf("%d ",map[i][j]); printf("\n");}printf("\n");
			horse();
			cannon();
			RR();
			GG();
			for(int i=0;i < count;i++){
				map[ans[i].x][ans[i].y]=9;
			}
/**///			for(int i=0;i < 10;i++){for(int j=0;j < 9;j++) printf("%d ",map[i][j]); printf("\n");}
			if(green.x <5 ) print();
			else{
					for(int j=0;j < 3;j++) 
					    for(int i=0;i < 3;i++) 
					        map[0+j][3+i]=map[9-j][3+i];
					print();        
			}    
    }
    return 0;
}


羁绊残阳
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
uva 50个题解
07-22
有uva刘汝佳文件夹的50道题解，从数据结构开始，以后慢慢上传
紫书题解3.象棋 （UVa 1589 综合） 附显示棋盘
一条咸鱼的博客
05-01 474
原题见https://vjudge.net/problem/UVA-1589 大意是判断黑将军是否被红棋（红帅，红车，红马，红炮）将死。注意可以将帅吃，如果黑将和红帅正对面并且中间没有其他棋子，算黑棋胜利。 代码没有AC，但是udebug里面的1000多个数据全部通过。找不到问题，也不知道怎么回事，我就当格式出了错误吧。 （码了几天，估计20个小时了，还是不行。。。） 思路： 为了方便判...
UVA1589象棋题目详解
weixin_63460193的博客
10-11 618
UVA1589象棋：模拟
《算法竞赛入门经典》UVA1589
DenisMe的博客
03-18 444
《算法竞赛入门经典》UVA1589题目题解大框架例外情况构建函数函数“马” &nbsp; 题目 &nbsp; &nbsp; &nbsp; 题解 大框架 首先构建函数的大框架——这个问题要怎么解决呢？ 可选项： 分析帝宫九个位置可否放置将或帅，储存在二位数组Room里（0为不可放置，1为可放置）。判断将或帅一步内可移动的位置在Room中的值是否为1。 将所有棋子置于容器中，判断每一个将或帅可移动的...
LIS.cpp.tar.gz_Help!_LIS acm_lis
09-21
描述提到"ACM LIS.cpp help you to let UVa Judge to accept your code"，意味着这个LIS.cpp文件是为了解决ACM竞赛中的问题而编写的，目标是让提交的代码在UVa平台上通过测试用例，即获得正确的输出结果。...
UVa11887 Tetrahedrons and Spheres
04-20
【标题】"UVa11887 Tetrahedrons and Spheres" 是一个编程竞赛题目，源自著名的在线算法竞赛平台UVa（University of Valladolid）。这个题目要求参赛者解决与几何形状&mdash;&mdash;四面体和球体相关的问题。 【描述】"测试...
UVa12313 A Tiny Raytracer
最新发布
04-24
《UVa12313：微小光线追踪器解析》 光线追踪是计算机图形学中的一个重要技术，它用于模拟光在虚拟环境中的传播和反射，以生成高度逼真的图像。在UVa在线判题系统中，有一个编号为12313的题目&mdash;&mdash;"A Tiny Raytracer...
UVa11726 Crime Scene 测试数据
03-01
UVa11726 Crime Scene 测试数据
uva.rar_UVA_机器人足球
09-24
机器人足球的底层代码，提供到开发环境中去，希望大家一起分享
Xiangqi UVA - 1589
Galaxy_12138的博客
01-28 635
大致说一下意思，一个黑将，然后红方已经将军了，现在轮到黑棋走，问黑棋还有没有活路了。 心路历程： 1.1月26号凌晨开始琢磨的，拿到题写了五十行，走的是把3*3将可以走的格子标记的办法，当时感觉有点问题，后来考虑到吃子的情况，扔了睡觉。 2.好吧，我没睡着，两点多爬起来写了两句思路。 3.周六走了一天的亲戚，写的伪代码，基本确定走点的办法。 4.晚上开始写......，wa，本人比较懒，
UVa1589
我爱coding的专栏
06-15 952
/* 题意很简单，就是黑方只剩下一个将，红方还有很多子，而且当前的残局是红方正在将军，判断红方是否已经将死黑方 红方只有四种棋子，帅，车，炮，马，因此按照每个棋子的运算规则，即可判断出红方已经能吃到的位置 1。给棋子编码，炮是1,马是2,车是3,因为在对将的时候帅的作用和车是一样的，因此把帅也编成3号，按照车处理 2.这中间使用两个棋盘来记录，mp是残局时每个棋子的位置，an记录判断后红方
uva1589 象棋 超简单代码 看到就是学到
artistkeepmonkey的博客
04-12 705
有看不明白的地方评论问我，看到必回。#include&lt;iostream&gt;#include&lt;string.h&gt;using namespace std;int out(int x,int y)//返回1说明黑将出了九宫格 { if((y==4||y==5||y==6)&amp;&amp;(x==1||x==2||x==3))return 0; else return 1;}vo...
UVA - 1589 Xiangqi (模拟)
luciozhang的博客
04-04 1005
Xiangqi Problem Description Xiangqi is one of the most popular two-player board games in China. The game represents a battle between two armies with the goal of capturing the enemy’s “genera
Uva 1589 象棋
h1120023921的博客
08-07 499
在temp数组中把红方所有棋子能到达的位置标‘1’，最后在黑将能走的地方判断一下有没有没被标‘1’的 没有则被将死。 #include #include using namespace std; char board[10][9]={},temp[10][9]={}; int G_G(int i,int j) { for(int i=7;i<10;i++) {
uva 1589
pb1995的博客
09-12 529
原题 象棋, 判断红棋是否能将死黑棋 因为轮到黑棋下了, 黑棋只有四种下法, 所以只需判断黑将往四个方向走一步后的情况即可(这里卡了好久, 一直把当前的状况也用来判断了) AC代码如下: #include #include #include #include #include #include #include #include #include #include
UVA 1589 Xiangqi——模拟
hao_zong_yin的博客
12-21 836
模拟题，我的做法是先让黑将分别上下左右移动，对每一种情况  先判断是否能被马将死（列举8种情况），然后判断是否能被 将 车 炮 将死（以黑将为中心十字展开，判断是否有 将 车 炮） 注意： 1.开局两将正对红方必输； 2.吃子情况； 3.输入问题（因为输入错了好多次） #include #include #include #include int main() { //
Fourth Point !!
07-28
- *2* [UVA 10242 || Fourth Point !!（求平行四边形第四点](https://blog.csdn.net/FXXKI/article/details/43375343)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值