Uva oj 816 Abbott Revenge（BFS最短路）

最新推荐文章于 2018-09-13 19:10:11 发布
最新推荐文章于 2018-09-13 19:10:11 发布
阅读量760 收藏 1
点赞数 2
文章标签： ACM BFS Uva 816 Abbott Revenge
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33266889/article/details/53308997
版权

  • 原题链接：Here！

  • 闲话：看到题目的时候还是很懵的，这个迷宫很特殊，特殊的地方在对于每一个点都多出来一些要求，比如进入一个交叉点的"朝向"( NESW，北东南西 )是不同的，对应不同的"朝向"，出去的方向也是不尽相同的。好吧，根本没有思路，真不愧是Final的题。
  • 部分变量设置：
    1. (r,c) 代表点的坐标，特殊的(r0,c0)代表Enterance，(r2,c2)代表Goal，(r1,c1)代表起始点
    2. dir   代表朝向，朝向有4个“N，E，S，W”，顺时针
    3. turn  代表转向方向，F直走，L左转，R右转
    4. d[r][c][dir] 代表起始点到点(r,c,dir)的最短长度
    5. p[r][c][dir] 代表点(r,c,dir)在BFS树上的父点
    6. has_edge[r][c][dir][turn] 判断是否可以转向
    7. dr[],dc[],struct Node{}的解释都在下面

  • 分析：现在回过头来看它与普通迷宫题在本质上是一样的，只不过是多出了一些条件。因为现在对于每一个点都会有三个状态，行r，列c，以及进入的方向dir，所以使用三元数组(r,c,dir)来表示状态“位于点(r,c)，朝向dir”。需要注意的是起点并不是(r0,c0)，题目中描述的是在规定的入口方向进入，所以开始的点应该是(r1,c1)，d[r][c][dir] 代表起始点到点(r,c,dir)的最短长度，p[r][c][dir] 代表点(r,c,dir)在BFS树上的父点。对于任意一个状态 U(r,c,dir) 和 其后继状态 V(r',c',dir')，如果在能够转向( has_edge[r][c][dir][turn]==1 )，后继点V(r,c)在图里且还没被遍历过，就将后继状态V加入到vector中，然后更新状态V最短长度和V的父结点。如果在BFS扩增中能够到达Goal，跳出循环返回ture，如果循环结束还没有找到Goal，返回false。

  • 实现：

    1.输入部分
    将4个方向N E S W 和 3个转向F L R 转换成数字0~3和0~2，这样可以简化问题。这技巧真很强，厉害。
    const char* dirs = "NESW";		// 顺时针旋转 
const char* turns = "FLR";		// 转弯方式 F直走，L左转，R右转
const int dr[] = {-1, 0, 1,  0};// 将4个方向和3种"转弯方式"编号为0~3和0~2	转弯方式：直走，左转，右转 
const int dc[] = { 0, 1, 0, -1}; 
    //    转换函数,将字符转换成数字 
int dir_id(char c) {	return strchr(dirs,c)-dirs; }		// 用法独特真的很强 
int turn_id(char c){  	return strchr(turns,c)-turns; }
    技巧balabala:先用字符指针指向了一个字符串常量，然后strchr(dirs,c)会返回字符c在字符串中第一次出现位置的指针，然后用 返回值 — 指向字符串的指针，就能得到字符c在字符串dirs中的"位置"了。厉害word刘。
     
    bool read_case(){
	char s[99],s2[99];
	scanf("%s",s);	
	if(s[0]=='E')	return false;
	if(scanf("%d%d%s%d%d",&r0,&c0,s2,&r2,&c2)!=5) return false;	// 录入起点和终点信息 
	printf("%s\n",s); 
	
	dir=dir_id(s2[0]);
	r1=r0+dr[dir];
	c1=c0+dc[dir];
	
	//除了1、2行特殊处理之外
	//对于其他行，首先输入(r,c)然后输入一些指令，指令个数和长度不确定 
	memset(has_edge,0,sizeof(has_edge)); 
	while(1){
		int r,c;
		scanf("%d",&r);
		if(r==0)	break;
		scanf("%d",&c);
		// 指令以*结束，指令第一个字符代表朝向，其他字符代表可转向的方向 
		while(scanf("%s",s)==1 && s[0]!='*'){
			for(int i=1;i<strlen(s);i++)
				has_edge[r][c][dir_id(s[0])][turn_id(s[i])]=1;
		}
	}
	return true;
}

    2.输出部分
    void print_ans(Node u){
	//倒序存放到vector中 
	vector<Node> nodes;
	while(1){
		nodes.push_back(u);
		if(d[u.r][u.c][u.dir]==0)	break;
		u=p[u.r][u.c][u.dir]; 
	}
	nodes.push_back(Node(r0,c0,dir));
	
	// 每行10个，注意每行开头有两个空格
	int cnt=0;
	for(int i=nodes.size()-1;i>=0;i--){
		if(cnt%10==0)	printf(" ");
		printf(" (%d,%d)",nodes[i].r,nodes[i].c);
		if(++cnt%10==0)	printf("\n");
	} 
	if(nodes.size()%10!=0)	printf("\n");
}

    3.最重要的部分
    对于任意一个状态 U(r,c,dir) 和 其后继状态 V(r',c',dir')，如果在能够转向( has_edge[r][c][dir][turn]==1 )，后继点V(r,c)在图里且还没被遍历过，就将后继状态V加入到vector中，然后更新状态V最短长度和V的父结点。如果在BFS扩增中能够到达Goal，跳出循环返回ture，如果循环结束还没有找到Goal，返回false。

    在分析里有一个很关键的问题，如果找到后继状态？
    // 接下来是"行走"函数，根据当前的状态和转弯方式，计算出后继状态
Node walk(const Node& u,int turn){
	int dir = u.dir;
	if(turn==1)	dir=(dir + 3) % 4;	// 左转，逆时针-1，但是不能出现负数，所以+3 %4 
	if(turn==2)	dir=(dir + 1) % 4;	// 右转，顺时针+1 
	return Node(u.r+dr[dir],u.c+dc[dir],dir);	// 返回后继状态 
}

    判断点V在图里
    bool inside(int r,int c){		// 判断是否在Maze里面 
	return (r>=1 && r<MAX && c>=1 && c<MAX);
}

    BFS
    void BFS(){ 
	queue<Node>	q;
	memset(d,-1,sizeof(d));
	Node u(r1,c1,dir);
	d[u.r][u.c][u.dir]=0;		// 第一个点在BFS树上的父亲自然是 0   
	q.push(u);
	while(!q.empty()){
		Node u=q.front();	q.pop();
		if(u.r==r2 && u.c==c2){ print_ans(u); return; }
		for(int i=0;i<3;i++){	// 四个方向进行遍历 
			Node v=walk(u,i);	// v代表u向方向i走的一个后继节点
			if(has_edge[u.r][u.c][u.dir][i] && inside(v.r,v.c) && d[v.r][v.c][v.dir]<0){
				d[v.r][v.c][v.dir]=d[u.r][u.c][u.dir]+1;
				p[v.r][v.c][v.dir]=u;
				q.push(v);
			} 
		} 
	}
	printf("  No Solution Possible\n");
}

  • CODE
    #include<vector>
#include<queue>
#include<cstdio>
#include<cstring>
using namespace std;

const int MAX = 10;
const char* dirs = "NESW";		// 顺时针旋转 
const char* turns = "FLR";		// 转弯方式 F直走，L左转，R右转
const int dr[] = {-1, 0, 1,  0};// 将4个方向和3种"转弯方式"编号为0~3和0~2	转弯方式：直走，左转，右转 
const int dc[] = { 0, 1, 0, -1}; 

struct Node{
	int dir,r,c;
	Node(int r=0, int c=0, int dir=0):r(r),c(c),dir(dir) {}	//构造函数 
}; 

int r0,c0,dir,r1,c1,r2,c2;		// r0,c0 起点坐标 r2,c2 终点坐标 
int has_edge[MAX][MAX][4][3];	// has_edge[r][c][dir][turn],四元数组，记录点(r,c)的朝向 和 可以选择的方向 
int d[MAX][MAX][4];
Node p[MAX][MAX][4];

//    转换函数,将字符转换成数字 
int dir_id(char c) {	return strchr(dirs,c)-dirs; }		// 用法独特真的很强 
int turn_id(char c){  	return strchr(turns,c)-turns; }

// 输入部分
bool read_case(){
	char s[99],s2[99];
	scanf("%s",s);	
	if(s[0]=='E')	return false;
	if(scanf("%d%d%s%d%d",&r0,&c0,s2,&r2,&c2)!=5) return false;	// 录入起点和终点信息 
	printf("%s\n",s); 
	
	dir=dir_id(s2[0]);
	r1=r0+dr[dir];
	c1=c0+dc[dir];
	
	//除了1、2行特殊处理之外
	//对于其他行，首先输入(r,c)然后输入一些指令，指令个数和长度不确定 
	memset(has_edge,0,sizeof(has_edge)); 
	while(1){
		int r,c;
		scanf("%d",&r);
		if(r==0)	break;
		scanf("%d",&c);
		// 指令以*结束，指令第一个字符代表朝向，其他字符代表可转向的方向 
		while(scanf("%s",s)==1 && s[0]!='*'){
			for(int i=1;i<strlen(s);i++)
				has_edge[r][c][dir_id(s[0])][turn_id(s[i])]=1;
		}
	}
	return true;
}
 
// 接下来是"行走"函数，根据当前的状态和转弯方式，计算出后继状态
Node walk(const Node& u,int turn){
	int dir = u.dir;
	if(turn==1)	dir=(dir + 3) % 4;	// 左转，逆时针-1，但是不能出现负数，所以+3 %4 
	if(turn==2)	dir=(dir + 1) % 4;	// 右转，顺时针+1 
	return Node(u.r+dr[dir],u.c+dc[dir],dir);	// 返回后继状态 
}

bool inside(int r,int c){		// 判断是否在Maze里面 
	return (r>=1 && r<MAX && c>=1 && c<MAX);
}
  
void print_ans(Node u){
	//倒序存放到vector中 
	vector<Node> nodes;
	while(1){
		nodes.push_back(u);
		if(d[u.r][u.c][u.dir]==0)	break;
		u=p[u.r][u.c][u.dir]; 
	}
	nodes.push_back(Node(r0,c0,dir));
	
	// 打印解，每行10个,
	int cnt=0;
	for(int i=nodes.size()-1;i>=0;i--){
		if(cnt%10==0)	printf(" ");
		printf(" (%d,%d)",nodes[i].r,nodes[i].c);
		if(++cnt%10==0)	printf("\n");
	} 
	if(nodes.size()%10!=0)	printf("\n");
}

void BFS(){ 
	queue<Node>	q;
	memset(d,-1,sizeof(d));
	Node u(r1,c1,dir);
	d[u.r][u.c][u.dir]=0;		// 第一个点在BFS树上的父亲自然是 0   
	q.push(u);
	while(!q.empty()){
		Node u=q.front();	q.pop();
		if(u.r==r2 && u.c==c2){ print_ans(u); return; }
		for(int i=0;i<3;i++){	// 四个方向进行遍历 
			Node v=walk(u,i);	// v代表u向方向i走的一个后继节点
			if(has_edge[u.r][u.c][u.dir][i] && inside(v.r,v.c) && d[v.r][v.c][v.dir]<0){
				d[v.r][v.c][v.dir]=d[u.r][u.c][u.dir]+1;
				p[v.r][v.c][v.dir]=u;
				q.push(v);
			} 
		} 
	}
	printf("  No Solution Possible\n");
} 

int main(){
	while(read_case()){
		BFS();
	}
	return 0;
}

  • 收获最大的是如果在遇到相同问题，明白"结点"包含哪些内容是很重要的。可以用多元数组描述一个多个参数的状态，在用数字代替字符"NESW"时也很精彩，walk()函数中找后继状态也很精彩。

  • Think：优秀的代码里透露出一种美，简直不可名状，恰好听到Unbelievable--Owl City/Hanson，Oh~我突然找到了发现新奇小玩具的那种快乐~~~  Unbelievable,You haven’t seen nothing yet,I'm so amazed, those were the days.




Cloud97
关注
专栏目录
uva816 -- Abbott's Revenge (BFS)
BestFSQ的博客
04-15 568
题目在此 这一题是求最短路，肯定是使用BFS来求解，然而这一题我的AC过程很不顺利，起初是迷之Runtime Error，我以为是输出的时候采用递归导致栈溢出，改成循环后还是RE，后来不知道改了什么，终于不RE了，又开始了无限Wrong Answer，还好最后找出了WA的原因：是我对输入理解有误导致的，比如题目给出的测试迷宫SAMPLE中，有这样的一组数据：1 2 WLF NR ER * ，我起
UVA816 Abbott的复仇 Abbott's Revenge（final的BFS）（真•答案）
繁凡さん的博客
02-19 356
写这道题差点没把我气死，网上的好多题解看了半天结果是假的… 题目PDF 【分析】 利用队列实现广度搜索BFS来遍历图寻找最短路径。 用一个三元组(r, c, dir)表示“位于(r, c)，面朝dir”这个状态。假设入口位置为(r0, c0)，朝向为dir，则初始状态并不是(r0, c0, dir)，而是(r1, c1, dir)，其中，(r1, c1)是(r0, c0)沿着方向d...
紫书上的例题，关于BFS
qq_38182397的博客
08-04 282
不知道该说些啥 #include #include #include #include using namespace std; struct Node { int r, c, dir; // 站在(r,c)，面朝方向dir(0~3分别表示N, E, S, W) Node(int r=0, int c=0, int dir=0):r(r),c(c),dir(dir) {} }; co
UVA - 816 Abbott's Revenge
weixin_30402343的博客
10-05 82
/* 这题和普通的迷宫题有类似之处，比较有趣的地方是，加了方向，所以处理时会麻烦一些，既要记录方向，还要记录父节点 收获 && 总结： 1. 复习了 strchr 函数 (作用：在C风格的字符串中，找到指定字符在串中的所在位置，要配合数组名使用，减去数组名才能得到所在位置的下标) http://blog.csdn.net/z...
【例题 6-14 UVA-816】Abbott's Revenge
10-22 146
【链接】 我是链接,点我呀:) 【题意】 在这里输入题意 【题解】 预处理出某个方向的左边、前边、右边是哪个方向就好了。 然后就是普通的bfs了。 hash存到某个点,走到这里的方向的最小距离。 dfs输出路径。 【代码】 #include <bits/stdc++.h> using namespace std; //[where in,point]mi...
Abbott的复仇(Abbott's Revenge)
梦空间
02-25 5867
Abbott's Revenge Time limit: 3.000 seconds Abbott’s Revenge Abbott’s Revenge  The 1999 World FinalsContest included a problem based on a “dicemaze.” At the time the pro
UVA 816 Abbott's Revenge
时间杀手Time的博客
02-19 395
https://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=757 BFS,有点复杂，看着别人的代码调试了半天，争取自己写出来。 import java.util.LinkedList; import java.util.Queue; import jav
UVaOJ-401(Palindromes).zip_401 Palindromes
09-22
标题中的"UVaOJ-401(Palindromes)"表明这是一个关于解决UVa Online Judge（UVa OJ）上编号为401的编程挑战，该挑战的主题是"Palindromes"，即回文串。回文串是指一个字符串无论从前读到后还是从后读到前都是相同的，...
UVA_OJ:竞赛问题的示例代码
04-01
【标题】"UVA_OJ:竞赛问题的示例代码" 涉及的是一个在线判题系统——University of Virginia Online Judge（UVA OJ）的相关编程挑战。UVA OJ是一个面向全球程序员的在线平台，它提供了大量编程竞赛题目，帮助参赛者...
uvaoj 习题题目
09-16
【uvaoj 习题题目】相关知识点详解 在编程学习和竞赛中，UVa Online Judge（简称UVa或OJ）是一个广受欢迎的在线评测系统，它为程序员提供了大量练习题目，涵盖算法、数据结构、数学等多个领域。通过解决这些题目，...
hexo-tag-oj:插入在线判断问题标签和 github 存储库。 UVa OJ，github 小部件
06-21
支持OJ ... {% oj uva 100 46705 %} {% oj github morris821028 hexo-tag-oj %} {% ojblock hex %} { "album" : [ { "cover": {"title": "<p>Stephanie Dola</p>", "class": "hex-1", "img" :
oj.rar_oj_oj 题目_你最喜欢的OJ_最喜欢的OJ_至今为止做的oj
09-21
我做的很少啊，好羡慕那些过百题的，以根据题目在OJ在找到题目
算法竞赛入门竞赛 入门经典 第六章 个人记录
没什么卵用的学习记录
09-13 783
  UVa 210 并行程序模拟（放弃 || 待补） 没看懂题意，但是有百度了一下duque 算是对duque有了一个大致的认识和了解 当然也有尝试。 本来想着去hdu找一些duque的题 结果 好像可以用上duque题目都比较高端 畏难而退orz   UVa 514 铁轨（待补） 再次败在题意 没懂 为什么 54321 可以Yes 而54123会是No 按照我的理解 54可以先在...
算法入门经典第六章 例题6-14 Abbott的复仇(Abbott's Revenge)BFS算法实现
weixin_30758821的博客
08-26 218
Sample Input 3 1 N 3 31 1 WL NR *1 2 WLF NR ER *1 3 NL ER *2 1 SL WR NF *2 2 SL WF ELF *2 3 SFR EL *0 Sample Output (3,1) (2,1) (1,1) (1,2) (2,2) (2,3) (1,3) (1,2) (1,1) (2,1)(2,2) (1,2)...
[UVa 816] Abbott 的复仇（Abbott's Revenge）
StarlitNight的博客
08-01 478
Judge：https://vjudge.net/problem/UVA-816 题意：一个迷宫，每个点限制了从哪一方向（东西南北）来的，只能往左右前走，然后问起点到终点的最短路径。
蓝桥杯 ALGO-96 算法训练 Hello World!
柳婼 の blog
03-03 612
描述 　　本题定义本学期作业题的输出格式，请认真阅读。 　　如无特殊说明，开头无空格，间隔符为1个空格，答案最后必须输出换行符("\n")。 输入格式 　　无 输出格式 　　Hello World! #include using namespace std; int main() { cout << "Hello World!" << endl; return 0;
蓝桥杯 算法练习 Abbott’s Revenge
language_zcx的博客
03-24 1092
问题描述　　在1999年的World Finals中有一个基于Dice Maze(骰子迷宫)的题目。在出题人编写那道题目的时候，他们并没有发现这种迷宫的创意来源。然而在那场比赛结束不久，创作了大量的这种迷宫的Robert Abbott先生，联系了比赛主办方并确认自己是骰子迷宫的原作者。我们很遗憾没有在去年的题目描述中感谢Abbott先生的原创意，但我们很高兴Abbott先生主动为今年的比赛提供他原...
基于大模型技术的算力产业监测服务平台设计
最新发布
09-17
内容概要：本文提出了一种新型算力产业监测服务平台的设计理念，运用国内自主研发的大模型技术支持，通过对传统技术的改进和完善，提出了三层架构的设计方法，即基础设施层（含向量数据库和模型训练）、大模型应用框架层（强化数据处理与多维关系挖掘）及业务层（如智能分析助手）。这种设计方案旨在提高算力产业发展监测与决策制定的质量。 适合人群：电信行业的从业人员及研究人员；算力产业链各环节管理者；政府相关机构和政策决策者。 使用场景及目标：在多种算力相关的应用场景（如云计算中心管理，数据中心监测，政策分析）中辅助决策者进行快速有效的信息获取和技术选择；助力算力产业发展方向的精确把控和战略调整。 其他说明：随着大模型技术的日臻成熟，该算力产业监测服务平台预计将进一步丰富自身的应用领域和服务深度，以促进算力行业更智慧化发展。
东华大学计算机学院oj最后70道题
07-02
东华大学计算机学院oj最后70道题是计算机学院学生们在课程中所遇到的挑战和机遇。这些题目涵盖了计算机科学和技术的不同领域和方向，需要学生们具备扎实的知识基础和解决问题的能力。 这70道题可以分为多个类别，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值