uva 10047 The Monocycle

最新推荐文章于 2018-11-16 10:28:25 发布
最新推荐文章于 2018-11-16 10:28:25 发布
阅读量433 收藏
点赞数
分类专栏： acm 文章标签： acm uva
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaohaowudi_grh/article/details/12616267
版权

这道题目消耗了我不少时间，通过这道题目的解答，我对于广度优先搜索的理解更加深刻了，在BFS里面，每一次对于下一步状态的拓展并不是像以前的简单BFS一样仅仅局限于在位置上的更新，而应该扩展到下一步所有可能到达的状态，例如这道题里面状态由四个维度上的值决定：X坐标，Y坐标，方向，颜色，所以应该用一个四维数组来维护BFS的访问矩阵，并且我深刻理解到，每一次状态的拓展的粒度必须要分到最细，因为一开始的时候写的程序里面每一次拓展状态的时候都是发生了位移的，其实这样分解状态的粒度不够细，造成了多次WRONG ANSWER，但是一直找不到原因在哪，后来恍然大悟，每一次的状态变化只能针对一个维度上的状态发生变化，不能够既移动又旋转，每一次要么向前一步，要么原地旋转，不能够把两种状态变化同时放在一次的状态拓展中。

#include <stdio.h>
#include <string.h>
#include <queue>
#include <functional>
#include <algorithm>
using namespace std;

#define		MAX		30
#define		UP		0
#define		DOWN	1
#define		LEFT	2
#define		RIGHT	3

#define		GREEN	0
#define		BLACK	1
#define		RED		2
#define		BLUE	3
#define		WHITE	4

int start_i, start_j;
int end_i, end_j;
char arr[MAX][MAX];
int visited[MAX][MAX][4][5];
int m, n;
int case_count;

char direc[4][10] = {"up", "down", "left", "right"};
char color[5][10] = {"green", "black", "red", "blue", "white"};

struct state
{
	int i;
	int j;
	int direc;
	int color;
};

bool operator < (const struct state &a, const struct state &b)
{
	return visited[a.i][a.j][a.direc][a.color] > visited[b.i][b.j][b.direc][b.color];
}

priority_queue< struct state, vector<struct state>, less<struct state> > q;


bool is_overflow(int i, int j)
{
	if( !(i>=1 && i<=m) )
		return true;

	if( !(j>=1 && j<=n) )
		return true;

	return false;
}
/*
void print_sta(struct state &sta)
{
	printf("(%d,%d,%s,%s)\n", sta.i, sta.j, direc[sta.direc], color[sta.color]);
}
*/

void bfs(int i, int j, int direc, int color)
{
	//while(!q.empty()) q.pop();
	
	priority_queue< struct state, vector<struct state>, less<struct state> > q;

	int min_step;
	struct state sta;
	int cur_i, cur_j, cur_direc, cur_color;
	sta.i = i; sta.j = j; sta.direc = direc; sta.color = color;
	visited[i][j][direc][color] = 1;
	q.push(sta);

	min_step = 0;
	while(!q.empty())
	{
		cur_i = q.top().i;
		cur_j = q.top().j;
		cur_direc = q.top().direc;
		cur_color = q.top().color;
		q.pop();
		
		if(cur_i==end_i && cur_j==end_j && cur_color==GREEN)
		{
			min_step = visited[cur_i][cur_j][cur_direc][cur_color];
			break;
		}


		if(cur_direc == UP)
		{
			//这是前进一步的状态
			if(!is_overflow(cur_i-1,cur_j) && arr[cur_i-1][cur_j]!='#')
			{
				if(visited[cur_i-1][cur_j][UP][(cur_color+1)%5] == 0)
				{
					visited[cur_i-1][cur_j][UP][(cur_color+1)%5] = visited[cur_i][cur_j][cur_direc][cur_color]+1;
					sta.i=cur_i-1; sta.j=cur_j; sta.direc=UP; sta.color=(cur_color+1)%5;
					q.push(sta);
					//print_sta(sta);
				}
			}

			//这是旋转的下一步的状态
			if(visited[cur_i][cur_j][DOWN][cur_color] == 0)
			{
				visited[cur_i][cur_j][DOWN][cur_color] = visited[cur_i][cur_j][cur_direc][cur_color]+2;
				sta.i=cur_i; sta.j=cur_j; sta.direc=DOWN; sta.color=cur_color;
				q.push(sta);
				//print_sta(sta);
			}

			if(visited[cur_i][cur_j][LEFT][cur_color] == 0)
			{
				visited[cur_i][cur_j][LEFT][cur_color] = visited[cur_i][cur_j][cur_direc][cur_color]+1;
				sta.i=cur_i; sta.j=cur_j; sta.direc=LEFT; sta.color=cur_color;
				q.push(sta);
				//print_sta(sta);
			}

			if(visited[cur_i][cur_j][RIGHT][cur_color] == 0)
			{
				visited[cur_i][cur_j][RIGHT][cur_color] = visited[cur_i][cur_j][cur_direc][cur_color]+1;
				sta.i=cur_i; sta.j=cur_j; sta.direc=RIGHT; sta.color=cur_color;
				q.push(sta);
				//print_sta(sta);
			}
		}

		if(cur_direc == DOWN)
		{
			//这是前进一步的状态
			if(!is_overflow(cur_i+1,cur_j) && arr[cur_i+1][cur_j]!='#')
			{
				if(visited[cur_i+1][cur_j][DOWN][(cur_color+1)%5] == 0)
				{
					visited[cur_i+1][cur_j][DOWN][(cur_color+1)%5] = visited[cur_i][cur_j][cur_direc][cur_color]+1;
					sta.i=cur_i+1; sta.j=cur_j; sta.direc=DOWN; sta.color=(cur_color+1)%5;
					q.push(sta);
					//print_sta(sta);
				}
			}

			//这是旋转的下一步的状态
			if(visited[cur_i][cur_j][UP][cur_color] == 0)
			{
				visited[cur_i][cur_j][UP][cur_color] = visited[cur_i][cur_j][cur_direc][cur_color]+2;
				sta.i=cur_i; sta.j=cur_j; sta.direc=UP; sta.color=cur_color;
				q.push(sta);
				//print_sta(sta);
			}

			if(visited[cur_i][cur_j][LEFT][cur_color] == 0)
			{
				visited[cur_i][cur_j][LEFT][cur_color] = visited[cur_i][cur_j][cur_direc][cur_color]+1;
				sta.i=cur_i; sta.j=cur_j; sta.direc=LEFT; sta.color=cur_color;
				q.push(sta);
				//print_sta(sta);
			}

			if(visited[cur_i][cur_j][RIGHT][cur_color] == 0)
			{
				visited[cur_i][cur_j][RIGHT][cur_color] = visited[cur_i][cur_j][cur_direc][cur_color]+1;
				sta.i=cur_i; sta.j=cur_j; sta.direc=RIGHT; sta.color=cur_color;
				q.push(sta);
				//print_sta(sta);
			}
		}

		if(cur_direc == LEFT)
		{
			//这是前进一步的状态
			if(!is_overflow(cur_i,cur_j-1) && arr[cur_i][cur_j-1]!='#')
			{
				if(visited[cur_i][cur_j-1][LEFT][(cur_color+1)%5] == 0)
				{
					visited[cur_i][cur_j-1][LEFT][(cur_color+1)%5] = visited[cur_i][cur_j][cur_direc][cur_color]+1;
					sta.i=cur_i; sta.j=cur_j-1; sta.direc=LEFT; sta.color=(cur_color+1)%5;
					q.push(sta);
					//print_sta(sta);
				}
			}

			//这是旋转的下一步的状态
			if(visited[cur_i][cur_j][RIGHT][cur_color] == 0)
			{
				visited[cur_i][cur_j][RIGHT][cur_color] = visited[cur_i][cur_j][cur_direc][cur_color]+2;
				sta.i=cur_i; sta.j=cur_j; sta.direc=RIGHT; sta.color=cur_color;
				q.push(sta);
				//print_sta(sta);
			}

			if(visited[cur_i][cur_j][UP][cur_color] == 0)
			{
				visited[cur_i][cur_j][UP][cur_color] = visited[cur_i][cur_j][cur_direc][cur_color]+1;
				sta.i=cur_i; sta.j=cur_j; sta.direc=UP; sta.color=cur_color;
				q.push(sta);
				//print_sta(sta);
			}

			if(visited[cur_i][cur_j][DOWN][cur_color] == 0)
			{
				visited[cur_i][cur_j][DOWN][cur_color] = visited[cur_i][cur_j][cur_direc][cur_color]+1;
				sta.i=cur_i; sta.j=cur_j; sta.direc=DOWN; sta.color=cur_color;
				q.push(sta);
				//print_sta(sta);
			}
		}

		if(cur_direc == RIGHT)
		{
			//这是前进一步的状态
			if(!is_overflow(cur_i,cur_j+1) && arr[cur_i][cur_j+1]!='#')
			{
				if(visited[cur_i][cur_j+1][RIGHT][(cur_color+1)%5] == 0)
				{
					visited[cur_i][cur_j+1][RIGHT][(cur_color+1)%5] = visited[cur_i][cur_j][cur_direc][cur_color]+1;
					sta.i=cur_i; sta.j=cur_j+1; sta.direc=RIGHT; sta.color=(cur_color+1)%5;
					q.push(sta);
					//print_sta(sta);
				}
			}

			//这是旋转的下一步的状态
			if(visited[cur_i][cur_j][LEFT][cur_color] == 0)
			{
				visited[cur_i][cur_j][LEFT][cur_color] = visited[cur_i][cur_j][cur_direc][cur_color]+2;
				sta.i=cur_i; sta.j=cur_j; sta.direc=LEFT; sta.color=cur_color;
				q.push(sta);
				//print_sta(sta);
			}

			if(visited[cur_i][cur_j][UP][cur_color] == 0)
			{
				visited[cur_i][cur_j][UP][cur_color] = visited[cur_i][cur_j][cur_direc][cur_color]+1;
				sta.i=cur_i; sta.j=cur_j; sta.direc=UP; sta.color=cur_color;
				q.push(sta);
				//print_sta(sta);
			}

			if(visited[cur_i][cur_j][DOWN][cur_color] == 0)
			{
				visited[cur_i][cur_j][DOWN][cur_color] = visited[cur_i][cur_j][cur_direc][cur_color]+1;
				sta.i=cur_i; sta.j=cur_j; sta.direc=DOWN; sta.color=cur_color;
				q.push(sta);
				//print_sta(sta);
			}
		}

	}


	printf("Case #%d\n", case_count);
	if(min_step == 0)
		printf("destination not reachable\n");
	else
		printf("minimum time = %d sec\n", min_step-1);
}

void func(int m, int n)
{
	::m = m; ::n = n;

	memset((void*)visited[0][0][0], 0, sizeof(int)*MAX*MAX*4*5);
	bfs(start_i, start_j, UP, GREEN);
}


int main(void)
{
	int m, n;
	int i, j;

	//freopen("input.dat", "r", stdin);
	case_count = 0;
	while(1)
	{
		scanf("%d %d", &m, &n);
		getchar();
		if(!m && !n)
			break;

		for(i=1; i<=m; i++)
		{
			for(j=1; j<=n; j++)
			{
				arr[i][j] = getchar();
				if(arr[i][j] == 'S')
				{ start_i = i; start_j = j; }
				if(arr[i][j] == 'T')
				{ end_i = i; end_j = j; }
			}
			getchar();
		}
		case_count ++;
		if(case_count >= 2)
			printf("\n");
		func(m, n);
	}

	return 0;
}


皓首不倦
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
UVA - 10047 The Monocycle（BFS + vis数组的理解）
小G的ACM之路
08-03 1164
Problem A: The Monocycle  A monocycle is a cycle that runs on one wheel and the one we will be considering is a bit more special. It has a solid wheel colored with five different colors as
mips-monocycle
07-23
独轮车 MIPS 实现 使用 MIPS 架构模拟 CPU 的 VHDL 系统的实现。 该系统由 32 个寄存器组成，每个寄存器为 32 位，结构为寄存器组。 程序和数据存储器的容量为 256 字节。 系统处理字为 32 位。...
Uva10047 The Monocycle
DlPF_C的博客
01-30 310
原题链接：https://vjudge.net/problem/UVA-10047 绞尽脑汁的图论题，虽然只是bfs但是要求到达的最小时间以及符合到达终点的条件还是需要思考一番。 用优先队列保证到达时间最小，每一个方块的访问方式由进入的方向以及轮子的颜色划分。 #include #define INF 0x3f3f3f3f using namespace std; int n,m; int
uva 10047 The Monocycle
@fei
11-16 237
原题： A monocycle is a cycle that runs on one wheel and the one we will be considering is a bit more special. It has a solid wheel colored with five different colors as shown in the figure: The colored...
UVa10047 The Monocycle
hahalidaxin的专栏
03-30 214
UVa10047 The Monocycle   链接：http://acm.hust.edu.cn/vjudge/problem/viewProblem.action?id=19491   （以上摘自http://blog.csdn.net/shuangde800/article/details/7686003）   【思路】   BFS。   以节点位置(x,y)方向dir
uva 10047 The Monocycle
iwi
02-15 203
题目：The Monocycle思路：bfs。代码：#include&lt;bits/stdc++.h&gt; using namespace std; #define maxn 25 int n,m; bool g[maxn+5][maxn+5]; //地图 struct Pair { int x,y; Pair(int xx=0,int yy=0) { x=xx,y=yy; }...
UWB Monocycle.zip
01-06
**超宽带单脉冲（UWB Monocycle）技术详解** 超宽带（Ultra-Wideband，简称UWB）是一种无线通信技术，它利用极短的脉冲信号在宽广的频谱上进行传输，通常这些脉冲的带宽远超过传统窄带通信系统的带宽。UWB ...
UWB Monocycle：显示高斯脉冲函数的时间波形。-matlab开发
05-30
UWB_monocycle.m 此 m 文件显示高斯脉冲函数的时间波形以及 0.5 纳秒脉冲宽度的高斯脉冲函数的一阶和二阶导数。 通过改变 fs,t,t1 可以使用其他脉冲宽度值。 该程序将实际的一阶和二阶导数方程式用于高斯脉冲波形。 ...
UWB monocycle pulse generation based on optical cross-polarization modulation
02-10
A novel all-optical method for ultra-wideband (UWB) ... After proper differential delay, an UWB monocycle pulse with 84-ps width and the fractional bandwidth of 153% is generated after photodetection.
通用的C++数据结构代码实现，使用模板
08-26
通用的C++数据结构代码实现，使用模板
ant-design-vue-1.2.2.zip
08-26
基于 Ant Design 和 Vue 的企业级 UI 组件库
基于Django完成一个企业级的官方网站的制作.zip
最新发布
08-26
基于Django完成一个企业级的官方网站的制作.zip
springboot364高校科研信息管理系统pf.zip
08-26
信息数据从传统到当代，是一直在变革当中，突如其来的互联网让传统的信息管理看到了革命性的曙光，因为传统信息管理从时效性，还是安全性，还是可操作性等各个方面来讲，遇到了互联网时代才发现能补上自古以来的短板，有效的提升管理的效率和业务水平。传统的管理模式，时间越久管理的内容越多，也需要更多的人来对数据进行整理，并且数据的汇总查询方面效率也是极其的低下，并且数据安全方面永远不会保证安全性能。结合数据内容管理的种种缺点，在互联网时代都可以得到有效的补充。结合先进的互联网技术，开发符合需求的软件，让数据内容管理不管是从录入的及时性，查看的及时性还是汇总分析的及时性，都能让正确率达到最高，管理更加的科学和便捷。本次开发的高校科研信息管理系统实现了操作日志管理、字典管理、反馈管理、公告管理、科研成果管理、科研项目管理、通知管理、学术活动管理、学院部门管理、科研人员管理、管理员管理等功能。系统用到了关系型数据库中王者MySql作为系统的数据库，有效的对数据进行安全的存储，有效的备份，对数据可靠性方面得到了保证。并且程序也具备程序需求的所有功能，使得操作性还是安全性都大大提高，让高校科研信息管理系统更能从理念走到现实，确确实实的让人们提升信息处理效率。
springboot363高校竞赛管理系统--pf.zip
08-26
高校竞赛管理系统管理系统按照操作主体分为管理员和用户。管理员的功能包括字典管理、论坛管理、竞赛公告管理、获奖管理、老师管理、评审管理、评审分配管理、评审打分管理、赛事管理、赛事提交管理、赛事报名管理、用户管理、专家管理、管理员管理。用户的功能等。该系统采用了Mysql数据库，Java语言，Spring Boot框架等技术进行编程实现。 高校竞赛管理系统管理系统可以提高高校竞赛管理系统信息管理问题的解决效率，优化高校竞赛管理系统信息处理流程，保证高校竞赛管理系统信息数据的安全，它是一个非常可靠，非常安全的应用程序。
ssm455重庆理工大学心理咨询管理子系统的分析与实现+jsp.zip
08-26
重庆理工大学心理咨询管理子系统主要是为学生提供心理咨询服务，该系统实现的功能包括学生基本信息管理，教师基本信息管理、队列查询、咨询预约，咨询报告等。
基于Django+Bootstrap框架，设计微型小说网站.zip
08-26
基于Django+Bootstrap框架，设计微型小说网站.zip
租房平台源码 （优秀毕业设计源码）
08-26
1. 租房平台代码说明：经导师指导并认可通过的98分毕设项目代码。 2.适用对象：本代码学习资料适用于计算机、电子信息工程、数学等专业正在做毕设的学生，需要项目实战练习的学习者，也适用于课程设计、期末大作业。 3.技术栈：java，项目代码都经过严格调试，代码没有任何bug！ 4. 作者介绍：大厂码农，java领域创作者，阿里云开发社区乘风者计划专家博主，专注于大学生项目实战开发，文章底部有博主联系方式，更多优质系统、项目定制请私信。 5. 最新计算机软件毕业设计选题大全: https://blog.csdn.net/weixin_45630258/article/details/135901374
springboot362在线租房和招聘平台pf.zip
08-26
在线租房和招聘平台管理系统按照操作主体分为管理员和用户。管理员的功能包括字典管理、房东管理、房屋管理、房屋收藏管理、房屋评价管理、房屋订单管理、论坛管理、平台资讯管理、企业管理、简历管理、简历投递管理、用户管理、职位招聘管理、职位收藏管理、职位留言管理、管理员管理。用户的功能等。该系统采用了Mysql数据库，Java语言，Spring Boot框架等技术进行编程实现。 在线租房和招聘平台管理系统可以提高在线租房和招聘平台信息管理问题的解决效率，优化在线租房和招聘平台信息处理流程，保证在线租房和招聘平台信息数据的安全，它是一个非常可靠，非常安全的应用程序。
前置资源haproxy.zip
08-26
haproxy和cdn
ant-design-vue-1.3.17.zip
08-26
基于 Ant Design 和 Vue 的企业级 UI 组件库
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值