TopCoder: RevolvingDoors BFS算法

最新推荐文章于 2022-02-19 17:03:13 发布
最新推荐文章于 2022-02-19 17:03:13 发布
阅读量1.5k 收藏
点赞数 2
分类专栏： TopCoder 文章标签： TopCoder BFS
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xzz_hust/article/details/9049361
版权

题目来源： RevolvingDoors


感觉这道题比前两道应用BFS算法的题目要难一些，不像之前的那么直接，如果这道题目要求的是最短的频数的话，那跟前两道就差不多了，但这里求的是最少旋转门的次数，这就有点复杂了，我的思路如下：

1. 判断当前位置是否是终点，不是则搜索由当前位置可以到达的旋转门，并将旋转之后的结果状态存入LD链表尾。

2. 从LD链表中取出第一个元素作为当前状态，重复步骤1.


遇到的问题：BFS算法需要设置一个访问状态标志，要不然会发生重复搜索同一个状态的情况，开始的时候我只是设置了一个visited数组确定搜索可到达的旋转门的过程不会出现重复搜索的过程，结果出现了大问题，因为搜索过程中，进入LD中的元素会有重复的，所以会进行大量的重复搜索，时间复杂度大大增加，而且遇到某些地图还会出现无限循环的情况，如地图示例1，而地图示例2直接就是算半天算不出来，后来我增加了一个 isVisited函数确保进入LD的元素跟以前进入过的元素没有重复，问题才解决了。

还有一个要注意的问题就是地图示例的情况不是旋转6次，而是7次，最后一次也要先旋转门才能到达终点，开始的程序少算了这一步。


代码如下：

欢迎大家提出改正意见或者在回复里面show上自己的代码微笑

/**
 * TopCoder:RevolvingDoors
 * （http://community.topcoder.com/stat?c=problem_statement&pm=3064&rd=5869）
 * Author: xuzhezhao
 * E-mail: zhezhaoxu@gmail.com
 * Blog: http://blog.csdn.net/xuzhezhaozhao/
 * Date: 2013/6/7
 */

#include <iostream>
#include <string>
#include <list>

using namespace std;

#define MAX 50			/* 地图无数限制数 */
#define DOORS_MAX 10		/* 门数限制 */

class RevolvingDoors
{
public:
	int turns(string map[]);
};

enum Door_State {H, V};		/* 门的状态，H：水平 V：竖直 */
typedef struct CurrentPos{
	int row;			/* 当前所处行 */
	int col;			/* 当前所处列 */
	Door_State door[MAX][MAX];	/* 门状态数组 */
	int door_pos[DOORS_MAX];	/* 门位置信息 */
	int doors_num;			/* 门数量 */
	int turn_doors;			/* trun的门数量 */
}CurrentPos;

static int map_rows = 0;	/* 地图行数 */
static int map_cols = 0;	/* 地图列数 */
static int end_row;		/* 终点所在行数 */
static int end_col;		/* 终点所在列数 */
static int visited[MAX][MAX];

void init(string map[], CurrentPos &curpos);
bool isEnd(CurrentPos curpos);
bool isVisited(list <CurrentPos> LV, CurrentPos curpos);

int main()
{
	RevolvingDoors revolvingdoors;
	
	/* 地图，以 "" 结尾 */
	string map[] = 
	{ 
	"#############",
	"#  #|##|#   #",
	"#   O  O    #",
	"# E || || S #",
	"#    O  O   #",
	"#   #|##|#  #",
	"#############", 
	"" };

	cout << revolvingdoors.turns(map) << endl;
	
	return 0;
}

int RevolvingDoors::turns(string map[])
{
	list <CurrentPos> LC;		/* LC: 内层BFS状态 */
	list <CurrentPos> LD;		/* LD: 外层BFS，turn 操作之后的状态 */
	list <CurrentPos> LV;		/* LV：外层BFS访问状态标志，类似visited数组，保存turn操作之后的状态，以避免重复 */
	CurrentPos curpos, nextpos;
	int row, col;

	init(map, curpos);
	LD.push_back(curpos);

	/* 外层BFS */
	while (!LD.empty()) {
		curpos = LD.front();
		LD.pop_front();

		/* 初始化visited数组 */
		for (int i = 0; i < MAX; i++) {
			for (int j = 0; j < MAX; j++) {
				visited[i][j] = false;
			}
		}

		LC.push_back(curpos);

		/* 内层BFS */
		while (!LC.empty()) {
			curpos = LC.front();
			LC.pop_front();
			row = curpos.row;
			col = curpos.col;
			visited[row][col] = true;

			if (isEnd(curpos)) {
				return curpos.turn_doors;
			}

			/* 可以向上下左右四个方向推进状态 */

			/* 向上走 */
			nextpos = curpos;
			if (row - 1 >= 0 && !visited[row-1][col]) {
				nextpos.row = row - 1;

				if (' ' == map[row-1][col]) {
					LC.push_back(nextpos);
				} else if ('*' == map[row-1][col]) {	/* 进入门的四周区域 */
					/* 门的位置有三种情况 */
					if (row - 2 >= 0 && 'O' == map[row-2][col] && H == curpos.door[row-2][col] ) {
						LC.push_back(nextpos);
					} else if (col + 1 <= map_cols - 1 && 
						'O' == map[row-1][col+1]) {
						if (V == curpos.door[row-1][col+1]) {
							LC.push_back(nextpos);
						} else {	/* turn door */
							nextpos.door[row-1][col+1] = V;
							++nextpos.turn_doors;
							visited[row-1][col] = true;
							if (!isVisited(LV, nextpos)){
								LV.push_back(nextpos);
								LD.push_back(nextpos);
							}
						}
					} else if (col - 1 >= 0 && 'O' == map[row-1][col-1]) {
						if (V == curpos.door[row-1][col-1]) {
							LC.push_back(nextpos);
						} else {
							nextpos.door[row-1][col-1] = V;
							++nextpos.turn_doors;
							visited[row-1][col] = true;
							if (!isVisited(LV, nextpos)){
								LV.push_back(nextpos);
								LD.push_back(nextpos);
							}
						}
					}
				}
			}

			/* 向下走 */
			nextpos = curpos;
			if (row + 1 <= map_rows - 1 && !visited[row+1][col]) {
				nextpos.row = row + 1;
				if (' ' == map[row+1][col]) {
					LC.push_back(nextpos);
				} else if ('*' == map[row+1][col]) {
					if (row + 2 <= map_rows - 1 && 'O' == map[row+2][col] &&
						H == curpos.door[row+2][col] ) {
						LC.push_back(nextpos);
					} else if (col + 1 <= map_cols - 1 && 'O' == map[row+1][col+1]) {
						if (V == curpos.door[row+1][col+1]) {
							LC.push_back(nextpos);
						} else {	/* turn door */
							nextpos.door[row+1][col+1] = V;
							++nextpos.turn_doors;
							visited[row+1][col] = true;
							if (!isVisited(LV, nextpos)){
								LV.push_back(nextpos);
								LD.push_back(nextpos);
							}
						}
					} else if (col - 1 >= 0 &&
						'O' == map[row+1][col-1]) {
						if (V == curpos.door[row+1][col-1]) {
							LC.push_back(nextpos);
						} else {
							nextpos.door[row+1][col-1] = V;
							++nextpos.turn_doors;
							visited[row+1][col] = true;
							if (!isVisited(LV, nextpos)){
								LV.push_back(nextpos);
								LD.push_back(nextpos);
							}
						}
					}
				}
			}

			/* 向左走 */
			nextpos = curpos;
			if (col - 1 >= 0 && !visited[row][col-1]) {
				nextpos.col = col - 1;
				if (' ' == map[row][col-1]) {
					LC.push_back(nextpos);
				} else if ('*' == map[row][col-1]) {
					if (col - 2 >= 0 && 'O' == map[row][col-2] &&
						V == curpos.door[row][col-2] ) {
						LC.push_back(nextpos);
					} else if (row - 1 >= 0 && 
						'O' == map[row-1][col-1]) {
						if (H == curpos.door[row-1][col-1]) {
							LC.push_back(nextpos);
						} else {	/* turn door */
							nextpos.door[row-1][col-1] = H;
							++nextpos.turn_doors;
							visited[row][col-1] = true;
							if (!isVisited(LV, nextpos)){
								LV.push_back(nextpos);
								LD.push_back(nextpos);
							}
						}
					} else if (row + 1 <= map_rows - 1 && 'O' == map[row+1][col-1]) {
						if (H == curpos.door[row+1][col-1]) {
							LC.push_back(nextpos);
						} else {
							nextpos.door[row+1][col-1] = H;
							++nextpos.turn_doors;
							visited[row][col-1] = true;
							if (!isVisited(LV, nextpos)){
								LV.push_back(nextpos);
								LD.push_back(nextpos);
							}
						}
					}
				}
			}

			/* 向右走 */
			nextpos = curpos;
			if (col + 1 <= map_cols - 1 && !visited[row][col+1]) {
				nextpos.col = col + 1;
				if (' ' == map[row][col+1]) {
					LC.push_back(nextpos);
				} else if ('*' == map[row][col+1]) {
					if (col + 2 <= map_cols - 1 && 'O' == map[row][col+2] &&
						V == curpos.door[row][col+2] ) {
							LC.push_back(nextpos);
					} else if (row + 1 <= map_rows - 1 && 
						'O' == map[row+1][col+1]) {
						if (H == curpos.door[row+1][col+1]) {
							LC.push_back(nextpos);
						} else {	/* turn door */
							nextpos.door[row+1][col+1] = H;
							++nextpos.turn_doors;
							visited[row][col+1] = true;
							if (!isVisited(LV, nextpos)){
								LV.push_back(nextpos);
								LD.push_back(nextpos);
							}
						}
					} else if (row - 1 >= 0 &&
						'O' == map[row-1][col+1]) {
						if (H == curpos.door[row-1][col+1]) {
							LC.push_back(nextpos);
						} else {
							nextpos.door[row-1][col+1] = H;
							++nextpos.turn_doors;
							visited[row][col+1] = true;
							if (!isVisited(LV, nextpos)){
								LV.push_back(nextpos);
								LD.push_back(nextpos);
							}
						}
					}
				}
			}
		}
	}
	return -1;
}

/**
 * 初始操作，获得地图的基本信息，行，列，门状态。并将门四周的4个点置为 '*' 字符，将 S， E 置为' '(空格)。
 */
void init(string map[], CurrentPos &curpos)
{
	int i, j;
	
	curpos.turn_doors = 0;

	while (map[map_rows] != "") {
		++map_rows;
	}
	if (map_rows > 0) {
		map_cols = map[0].length();
	}

	for (i = 0; i < map_rows; i ++) {
		for (j = 0; j < map_cols; j++) {
			if ('S' == map[i][j]) {
				curpos.row = i;
				curpos.col = j;
				map[i][j] = ' ';
			}
			if ('E' == map[i][j]) {
				end_row = i;
				end_col = j;
				map[i][j] = ' ';
			}
		}
	}
	curpos.doors_num = 0;
	for (i = 0; i < map_rows; i ++) {
		for (j = 0; j < map_cols; j++) {
			if ('O' == map[i][j]) {
				curpos.door_pos[curpos.doors_num] = i * map_cols + j;
				++curpos.doors_num;
				if ('|' == map[i+1][j]) {
					curpos.door[i][j] = V;
				} else {
					curpos.door[i][j] = H;
				}
				map[i+1][j] = map[i-1][j] =
					map [i][j+1] = map[i][j-1] = '*';
			}
		}
	}
}

/**
 * 判断是否到达终点
 */
bool isEnd(CurrentPos curpos)
{
	if (curpos.row == end_row && curpos.col == end_col) {
		return true;
	} else {
		return false;
	}
}

/**
 * 外层BFS访问标志，若LV中含有curpos状态，返回true，否则返回false
 */
bool isVisited(list <CurrentPos> LV, CurrentPos curpos)
{
	list<CurrentPos>::iterator it;
	int door_row, door_col;
	bool flag;
	if (LV.empty()) {
		return false;
	}
	for (it = LV.begin(); it != LV.end(); it++) {
		if (it->row == curpos.row && it->col == curpos.col) {
			flag = true;
			for (int i = 0; i < curpos.doors_num; i++) {
				door_row = curpos.door_pos[i] / map_cols;
				door_col = curpos.door_pos[i] % map_cols;
				if (it->door[door_row][door_col] != curpos.door[door_row][door_col]) {
					flag = false;
					break;
				}
			}
			if (flag) {
				return true;
			}
		}
	}
	return false;
}


xuzhezhaozhao
关注
专栏目录
TopCoder：ZigZag（动态规划--最长非降子序列）
yf224的博客
05-09 1044
看动态规划的题 在topcoder里看的这道题就来练练手 Problem Statement  A sequence of numbers is called a zig-zag sequence if the differences between successive numbers strictly alternate between positive and negative. T
Topcoder:Zigzag 最长的大小交替子数组
littlebirdman的专栏
04-27 2359
在topcoder上闲逛，看到了这个题，就索性做了一下。 题意：zigzag序列是指数组中连续元素之间的差正负交替，第一个差（若存在）可正可负，只有一个元素时也可被看成是一个zigzag序列。 例如：1,7,4,9,2,5是一个zigzag序列，因为连续元素之间的差值为6,-3,5,-7,3正负交替。1,4,7,2,5和1,7,4,5,5不是zigzag序列，因为前者的前两个差值为3,3；后者
TopCoder: CaptureThemAll BFS算法
xuzhezhaozhao的专栏
06-04 1318
题目来源：CaptureThemAll 思路：knight在棋盘每个位置上有三个状态，一是没有吃到rook和queen，二是吃到了rook，没有吃到queen，三是吃到了queen，没有吃到rook，全部吃到的话搜索结束，则knight工共有3 * 64个状态，64为棋盘位置数，故采用BFS算法，代码如下： 之前的代码有一点问题，现修改如下： /** * TopCoder:
TopCoder: SmartWordToy BFS算法
xuzhezhaozhao的专栏
06-02 1446
题目：SmartWordToy 思路：4个字母的单词有26 ^ 4种组合，可以看成是26 ^ 4种状态，用BFS搜索最短步骤。 代码如下： /* * TopCoder: SmartWordToy (http://community.topcoder.com/stat?c=problem_statement&pm=3935&rd=6532) * Author: xuz
TopCoder: WalkingHome BFS算法
xuzhezhaozhao的专栏
06-08 1203
题目来源：WalkingHome 与RevolvingDoors解法类似。 /* * TopCoder: WalkingHome * Author: xuzhezhao * E-mail: zhezhaoxu@gmail.com * Blog: http://blog.csdn.net/xuzhezhaozhao * Time: 2013/6/8 */ #inc
Topcoder：SRM 708 算法题解
Hans__Yang的博客
02-11 1784
题目翻译 250分题目：SafeBetting 赌徒有b块钱，他想把自己手上的钱增加到c块，同时他又不想输的太惨，因此必须保证每次下注后手上不少于a块钱。每次下注，赢了则下注的钱按双倍奉还（收益率100%），输了则分文不剩（收益率-100%）。问赌徒至少需要下注几次才能达到目标。 500分题目：BuildingStrings 定义一个字符串的得分score为：字符串
TopCoder竞争性编程：有竞争力的编程资源
haimianjie2012的专栏
02-19 118
1.学习茁壮成长 TopCoder thrive 动态规划：从新手到高级 2.有用的链接
TopCoder新算法记录
weixin_38948771的博客
06-19 429
TopCoder新算法记录： 今天做的TopCoder题如下： Problem Statement   This task is about the scoring in the first phase of the die-game Yahtzee, where five dice are used. The score is determined
TopCoder:TopCoder
05-23
【标题】"TopCoder:TopCoder" 【描述】"TopCoder是一个全球知名的在线编程竞赛平台，它提供了大量的算法挑战，帮助程序员提升技能并与其他高手竞技。TopCoder练习问题解决方案通常涉及各种算法和数据结构，是学习和...
topcoder:Topcoder解决方案
05-12
标题 "topcoder:Topcoder解决方案" 指的是在Topcoder平台上进行的算法竞赛和解决方案。Topcoder是一个全球知名的在线编程竞赛平台，它为程序员提供了一个展示编程技能、学习算法和解决问题的场所。参赛者通常需要...
topcoder:topcoder问题
05-20
【标题】：“topcoder:topcoder问题” 在编程竞赛领域，TopCoder是一个广为人知的平台，它提供了各种算法挑战，旨在提升参赛者的编程技能，尤其是C++编程能力。TopCoder的问题涵盖了数据结构、算法、数学等多个方面...
topcoder:一些topcoder问题
07-09
【标题】: "TopCoder: 详解Topcoder平台上的编程挑战与Java技术应用" 在编程竞赛的世界里，TopCoder是一个非常知名的在线平台，它提供了一系列的算法竞赛、软件设计比赛以及编码挑战，吸引了全球众多程序员参与。这...
TopCoder:TopCoder 练习题
06-29
TopCoder 练习 一个 Eclipse 项目，它将包含我用 Java 编写的 TopCoder 的所有实践问题。 包命名约定 会话类型，后跟其 ID 号和分区。 类型###.DIV# Eclipse 版本信息 版本：Luna Service Release 1 (4.4.1) 版本...
考研复习-英语二真题考试题集-带答案
09-14
英语二考研真题复习资料，带答案版
2024中美独角兽公司发展分析报告.pdf
09-14
全球各大洲独角兽企业分布、中美独角兽企业对比（数量、估值、新增及退榜情况、行业分布、所在城市）、
C++ 中的异步编程模型是什么
09-14
在C++中，异步编程模型是处理并发任务、提高程序性能和响应性的关键技术。以下是C++中实现异步编程的几种主要方式： 每种异步编程模型都有其适用场景和优缺点。选择合适的模型可以提高代码的可读性、可维护性和性能。随着C++标准的不断发展，异步编程模型也在不断进化，为开发者提供了更多的工具和选择。 在实际开发中，应根据具体需求选择合适的异步编程模型。例如，对于简单的异步任务，回调函数可能是最直接的选择；而对于需要结构化错误处理和结果获取的复杂异步任务，std::async和std::future可能更合适；在需要高效资源管理的场景下，线程池是一个不错的选择；而对于需要编写大量异步代码的现代应用程序，协程提供了一种更简洁、更直观的解决方案。 总之，C++中的异步编程模型是多核和高并发环境下提高程序性能的重要工具。通过合理使用这些模型，开发者可以构建出更高效、更可靠的软件系统。
正则表达式Regex是一种文本模式.docx
最新发布
09-14
正则表达式（Regular Expression，简称Regex或Regexp）是一种文本模式，包括普通字符（例如，a 到 z 之间的字母）和特殊字符（称为"元字符"）。正则表达式使用单个字符串来描述、匹配一系列符合某个句法规则的字符串。正则表达式是强大的文本处理工具，广泛用于搜索、编辑或操作文本和数据。 基本组成 普通字符：大多数字符，包括所有大写和小写字母、所有数字、所有标点符号和一些其他符号，都是普通字符。正则表达式中的普通字符表示它们自身。例如，正则表达式test会匹配字符串"test"。 特殊字符（元字符）：一些字符在正则表达式中具有特殊的意义，如^、$、.、*、+、?、{、}、[、]、|、\等。这些特殊字符用于表示在搜索文本时要匹配的一个或多个字符。例如，.匹配除换行符之外的任何单个字符。 字符类：字符类允许你指定一组字符中的任何一个字符。例如，[abc]匹配"a"、"b"或"c"中的任意一个字符。你也可以使用范围，如[a-z]匹配任何小写字母。 预定义字符类：正则表达式提供了一些预定义字符类，用于匹配常见的字符集合。例如，\d匹配任何数字（等价于[0-9]），\s匹配任
基于struts+sqlserver网络购物系统毕业课程源码设计+论文资料
09-14
编号：150 系统功能： 展示网站最新的商品信息。 展示网站特价的商品信息。 为用户提供修改个人资料和查看在网站操作情况的平台。 提供用户在网站上购物的平台。 展示网站发布的公告信息。 展示商品的销量排行。 展示网站的友情链接信息。 对商品详细信息以及分类信息进行管理。 对用户基本资料、交易制度、消费情况及留言信息进行管理。 对用户提交的订单进行管理。 对管理员信息、网站公告信息、商业资讯信息及友情链接信息进行管理。 系统运行稳定，具有强大的数据处理能力。 操作注意事项 （1）本系统的用户名为：admin，密码为：admin （2）admin管理员的信息不能删除。 （3）用户注册登录后，可进行商品购买、商品信息查看以及订单查询操作。 （4）后台登陆地址：http://localhost:8080/WebShopping/bg-land.jsp。
TopCoder讲座：注册教程+算法设计指南
TopCoder是一个知名的在线编程竞赛平台，提供了丰富的算法挑战和编程解决方案。在这个讲座中，我们将深入探讨如何在TopCoder 2008年中国锦标赛中进行注册、使用平台以及学习算法设计。以下是详细的步骤指南： 1. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值