Problem 2124 吃豆人 （BFS）

最新推荐文章于 2023-01-05 20:03:44 发布
最新推荐文章于 2023-01-05 20:03:44 发布
阅读量1.1k 收藏 2
点赞数
分类专栏： 赛后补题 搜索
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sdjzping/article/details/13351713
版权

1、http://acm.fzu.edu.cn/problem.php?pid=2124

2、

D - 吃豆人
Time Limit:1000MS    Memory Limit:32768KB    64bit IO Format:%I64d & %I64u

Description

吃豆人是一款非常经典的游戏，游戏中玩家控制吃豆人在地图上吃光所有豆子，并且避免被怪物抓住。

这道题没有怪物，将游戏的画面分成n*m的格子，每格地形可能为空地或者障碍物，吃豆人可以在空地上移动，吃豆人每移动一格需要1s时间，并且只能朝上下左右四个方向移动，特别的是吃豆人还能吐出舌头，舌头每移动一格需要0.1s时间，舌头只可以走直线。不必考虑吃豆人转身所需要的时间。

举例，吃豆人在(1,1)坐标，而豆子在(1,5)坐标，并且中间没有障碍物，此时朝豆子方向吐舌头～，经过0.8s就可以吃到豆子(来回各0.4s,吐出去的舌头要缩回来的嘛)。

游戏中还有加速道具，一旦得到加速道具，吃豆人就获得2倍移动速度，吐舌头的速度没有增加，即走1格用0.5s。现在地图上有且只有一颗豆子。游戏中有.代表空地；X表示障碍，吃豆人不能越过障碍；B代表豆子；S代表加速道具，并且地图上道具总数不超过1个，道具所在的位置为空地，得到道具后立即使用，道具立即消失，地形变为空地，不能用舌头去取道具；P表示吃豆人,吐舌头的时候吃豆人不能移动。

Input

输入包含多组数据。输入第一行有两个个整数n,m(2<=n,m<=20)，接着一个n*m的地图矩阵。

对于50%的数据，地图上没有道具。

Output

输出一行，最快用多少s吃到豆子,结果保留1位小数，如果吃不到，输出-1。

Sample Input

2 2
XP
B.
3 2
XP
.S
B.

Sample Output

1.2
1.7

参考网上ＡＣ代码：

#include<stdio.h>
#include<math.h>
#include<string.h>
#include<algorithm>
using namespace std;
#define INF 100000
#include <queue>
char map[25][25];
int sx,sy,bx,by,px,py,n,m;
double tg[25][25];
int dir[4][2]={0,1,1,0,-1,0,0,-1};
int visit[25][25];
struct node
{
    int x;
    int y;
    double t;
}a[500];
//处理舌头的时候注意分别向两端处理
void init() { //处理与豆在同一行或者同一列的格子
	memset(tg, 0, sizeof(tg));
	for (int i = bx + 1; i <=n; i++) {
		if (map[i][by] != 'X')
			tg[i][by] = (i - bx) * 0.2;
		else
			break;
	}
	for (int i = bx - 1; i > 0; i--) {
		if (map[i][by] != 'X')
			tg[i][by] = (bx - i) * 0.2;
		else
			break;
	}
	for (int i = by + 1; i <= m; i++) {
		if (map[bx][i] != 'X')
			tg[bx][i] = (i - by) * 0.2;
		else
			break;
	}
	for (int i = by - 1; i > 0; i--) {
		if (map[bx][i] != 'X')
			tg[bx][i] = (by - i) * 0.2;
		else
			break;
	}
}


double bfs(int Sx,int Sy,char e,double time)
{
    memset(visit,0,sizeof(visit));
    int front=0,rear=1;
    a[0].x=Sx;
    a[0].y=Sy;
    a[0].t=0;
    visit[Sx][Sy]=1;
    double ans=INF;
    while(front<=rear)
    {
        node cur=a[front++];
        if(map[cur.x][cur.y]==e)
        ans=min(ans,cur.t);
        else if(e=='B' && tg[cur.x][cur.y]!=0)
        ans=min(ans,cur.t+tg[cur.x][cur.y]);
        for(int i=0;i<4;i++)
        {
            int tx=cur.x+dir[i][0];
            int ty=cur.y+dir[i][1];
            if(tx>=1 && tx<=n && ty>=1 && ty<=m && map[tx][ty]!='X' && visit[tx][ty]==0)
            {
                visit[tx][ty]=1;
                node tmp;
                tmp.x=tx;
                tmp.y=ty;
                tmp.t=cur.t+time;
                a[rear++]=tmp;
            }
        }
    }
    return ans;
}
queue<node> que;
double bfs1(int x, int y, char end, double time) { //(x,y)为起点，end为结束点，t为走一步花的时间
	while (!que.empty()) {
		que.pop();
	}
	memset(visit, 0, sizeof(visit));
	double ans=10000;
	node first;
	first.x = x, first.y = y, first.t = 0;
	que.push(first);
	visit[x][y] = true;
	while (!que.empty()) {
		first = que.front();
		que.pop();
		if (map[first.x][first.y] == end) {
			ans = min(ans, first.t);
		} else if (end == 'B' && tg[first.x][first.y] != 0) {
			ans = min(ans, first.t + tg[first.x][first.y]);
		}
		for (int i = 0; i < 4; i++) {
			int xx = first.x + dir[i][0], yy = first.y + dir[i][1];
			if (xx>=1 && xx<=n && yy>=1 && yy<=m && map[xx][yy] != 'X' && !visit[xx][yy]) {
				node tmp;
				tmp.x = xx;
				tmp.y = yy;
				tmp.t = first.t + time;
				que.push(tmp);
				visit[xx][yy] = 1;
			}
		}

	}
	return ans;
}

int main()
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        getchar();
        int px=py=sx=sy=bx=by=-1;
        for(int i=1; i<=n; i++)
        {
            for(int j=1; j<=m; j++)
            {
                scanf("%c",&map[i][j]);
                if(map[i][j]=='S')
                {
                    sx=i;
                    sy=j;
                }
                if(map[i][j]=='B')
                {
                    bx=i;
                    by=j;
                }
                if(map[i][j]=='P')
                {
                    px=i;
                    py=j;
                }
            }
            getchar();
        }
        init();
        double ans1=INF,ans2=INF,ans3=INF;
        //printf("*%d %d\n",px,py);
        ans1=bfs(px,py,'S',1);
        //printf("ans1=%lf\n",ans1);
        if(ans1!=INF)
            ans2=bfs(sx,sy,'B',0.5);
        if(ans2!=INF)
            ans1+=ans2;
        else
            ans1=INF;
        ans3=bfs(px,py,'B',1);
        //printf("%lf %lf %lf\n",ans1,ans2,ans3);
        if(ans3==INF)
            printf("-1\n");
        else
            printf("%.1lf\n",min(ans1,ans3));
    }
    return 0;
}
/*
2 2
XP
B.
3 2
XP
.S
B.
*/



AC代码： 

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#include <algorithm>
using namespace std;

#define SIZE 22

struct Node {
	int x, y;
	double time;
};

int n, m;
char mat[SIZE][SIZE];
bool vis[SIZE][SIZE];
double tg[SIZE][SIZE]; //记录吐舌头的速度
int Px, Py, Sx, Sy, Bx, By;
int dx[] = { -1, 0, 1, 0 }, dy[] = { 0, -1, 0, 1 };
queue<Node> que;

void init() { //处理与豆在同一行或者同一列的格子
	memset(tg, 0, sizeof(tg));
	for (int i = Bx + 1; i < n; i++) {
		if (mat[i][By] != 'X')
			tg[i][By] = (i - Bx) * 0.2;
		else
			break;
	}
	for (int i = Bx - 1; i >= 0; i--) {
		if (mat[i][By] != 'X')
			tg[i][By] = (Bx - i) * 0.2;
		else
			break;
	}
	for (int i = By + 1; i < m; i++) {
		if (mat[Bx][i] != 'X')
			tg[Bx][i] = (i - By) * 0.2;
		else
			break;
	}
	for (int i = By - 1; i >= 0; i--) {
		if (mat[Bx][i] != 'X')
			tg[Bx][i] = (By - i) * 0.2;
		else
			break;
	}
	for(int i=0;i<n;i++)
	printf("*%d ",tg[i][By]);
	printf("\n");
	for(int i=0;i<m;i++)
	printf("&%d ",tg[Bx][i]);
	printf("\n");
}

bool ok(int x, int y) {
	return x >= 0 && x < n && y >= 0 && y < m;
}

double bfs(int x, int y, char end, double t) { //(x,y)为起点，end为结束点，t为走一步花的时间
	while (!que.empty()) {
		que.pop();
	}
	memset(vis, false, sizeof(vis));
	double ans=10000;
	Node first;
	first.x = x, first.y = y, first.time = 0;
	que.push(first);
	vis[x][y] = true;
	while (!que.empty()) {
		first = que.front();
		que.pop();
		if (mat[first.x][first.y] == end) {
			ans = min(ans, first.time);
		} else if (end == 'B' && tg[first.x][first.y] != 0) {
			ans = min(ans, first.time + tg[first.x][first.y]);
		}
		for (int i = 0; i < 4; i++) {
			int xx = first.x + dx[i], yy = first.y + dy[i];
			if (ok(xx, yy) && mat[xx][yy] != 'X' && !vis[xx][yy]) {
				Node tmp;
				tmp.x = xx;
				tmp.y = yy;
				tmp.time = first.time + t;
				que.push(tmp);
				vis[xx][yy] = true;
			}
		}

	}
	return ans;
}

int main() {
	while (scanf("%d%d", &n, &m) != EOF) {
		Px = Py = Sx = Sy = Bx = By = -1;
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < m; j++) {
				scanf(" %c", &mat[i][j]);
				if (mat[i][j] == 'P')
					Px = i, Py = j;
				if (mat[i][j] == 'S')
					Sx = i, Sy = j;
				if (mat[i][j] == 'B')
					Bx = i, By = j;
			}
		}
		init();
		printf("*%d %d\n",Px,Py);
		double ans1 = bfs(Px, Py, 'S', 1);
		double tmpans = 10000;
		if (ans1 != 10000) {
			tmpans = bfs(Sx, Sy, 'B', 0.5);
		}
		if (tmpans != 10000)
			ans1 += tmpans;
		else
			ans1 = 100000;
		double ans2 = bfs(Px, Py, 'B', 1);
		printf("%lf %lf %lf\n",ans1,ans2);
		if (ans2 == 10000)
			puts("-1");
		else
			printf("%.1lf\n", min(ans1, ans2));
	}
}


sdjzping
关注
专栏目录
google面试题
vinacky
08-15 694
https://hjptriplebee.github.io/Google面试经历-一.html/ 看到上面这个博客中的一道面试题，如下 有一个n*n的棋盘，上面有m个糖果，最开始有一个人在棋盘左上角，他可以向左向右或者向下移动，但不能向上移动，问他最少需要多少步吃完所有糖果。 写一下自己的思路和代码，因为没有OJ可以验证，不知道对错，暂且记录一下。 思路：动态规划求解 动规计算如果从...
吃豆子小游戏
风斯在下
01-07 4658
#include <stdio.h> #include <iostream> #include <time.h> #include <conio.h> #include <windows.h> #include <stdlib.h> #include <string.h> using namespace std; const int n = 809; struct Point { int
某车企笔试题解答（1）
liji_digital的博客
11-14 709
某车企笔试题解答（1），最长路径问题
python小游戏毕设 吃豆人小游戏设计与实现 (源码)
最新发布
mojikopi的博客
01-05 2160
🔥 Hi，各位同学好呀，这里是L学长！🥇今天向大家分享一个今年(2022)最新完成的毕业设计项目作品python小游戏毕设 吃豆人小游戏设计与实现 (源码)🥇 学长根据实现的难度和等级对项目进行评分(最低0分，满分5分)难度系数：3分工作量：3分创新点：4分吃豆人是电子游戏历史上的经典街机游戏，由Namco公司的岩谷彻设计并由Midway Games在1980年发行。Pac-Man被认为是80年代最经典的街机游戏之一，游戏的主角小精灵的形象甚至被作为一种大众文化符号，或是此产业的代表形象。
给定一个M*N的格子或棋盘，从左下角走到右上角的走法总数（每次只能向右或向上移动一个方格边长的距离）
热门推荐
梵解君
10-11 2万+
解答：我们可以把棋盘的左下角看做二维坐标的原点(0,0)，把棋盘的右上角看做二维坐标(M,N)(坐标系的单位长度为小方格的变长)    用f(i,j)表示移动到坐标f(i,j)的走法总数，其中0=设f(m,n)代表从坐标（0,0）到坐标（m,n）的移动方法，则 f(m,n)=f(m-1,n)+f(m,n-1). 于是状态f(i,j)的状态转移方程为： f(i,j)=f(i-1,
js+canvas实现动态吃豆人效果
10-20
本文将详细解析如何通过JS和Canvas来创建一个简单的动态吃豆人动画。 首先，Canvas是HTML5的一个重要组成部分，它提供了一个二维绘图表面，允许开发者直接在网页上进行图形绘制。在HTML文件中，我们通过`<canvas>`...
吃豆人C/c++实现
05-01
吃豆人是一款经典的电子游戏，它的C/C++实现展示了如何在命令行环境下创建一个互动的游戏。这个项目将涉及几个关键的编程概念和技术，包括游戏循环、图形绘制、碰撞检测、路径寻找以及对象交互。 首先，我们要理解...
常熟理工学院《Linux系统管理与维护》C++吃豆人课程设计报告及源代码
06-05
常熟理工学院《Linux系统管理与维护》C++吃豆人课程设计报告及源代码常熟理工学院《Linux系统管理与维护》C++吃豆人课程设计报告及源代码常熟理工学院《Linux系统管理与维护》C++吃豆人课程设计报告及源代码常熟理工...
JAVA实现的小游戏吃豆人源码.zip
01-15
吃豆人是一款经典的游戏，由Namco公司在1980年推出，因其简单而有趣的游戏机制深受玩家喜爱。本项目是使用Java编程语言实现的吃豆人小游戏，它旨在重现原版游戏的基本功能，同时也提供了学习Java编程和游戏开发的...
searchAgents的副本.py_py吃豆人_pacman_rowiad_searchAgents.py_searchage
09-29
在本文中，我们将深入探讨基于Python的人工智能项目——吃豆人（Pacman）中的搜索算法。这个项目名为"searchAgents的副本.py"，它包含了实现吃豆人游戏AI搜索策略的代码。该项目的主要目标是设计和实现各种搜索代理...
C语言_写简易吃豆人小游戏
EEowynn的博客
07-23 4249
简易参考这个视频：听一遍就懂： https://www.bilibili.com/video/BV1SB4y1u7gp?t=1185 大致能实现：生成豆子，躲避敌人，计分（有一点问题） 我自己加上了豆子和吃豆子的部分： 豆子很简单，随机生成就行，吃豆子要看边界条件 代码比较长，没有分流到其他头文件 环境：visual studio 2019 注意看 项目 -> 属性：有几个地方要调：注意平台是win32 1.使用多字节字符集 2.C/C++里面 SDL检查设置为否 应该就这些了，其他没问题 图片自己
棋盘【NOIP2017】
算法小猪的博客
07-25 1415
棋盘 有一个m×mm×mm×m的棋盘，棋盘上每一个格子可能是红色、黄色或没有任何颜色的。你现在要从棋盘的最左上角走到棋盘的最右下角。 任何一个时刻，你所站在的位置必须是有颜色的（不能是无色的）， 你只能向上、 下、左、 右四个方向前进。当你从一个格子走向另一个格子时，如果两个格子的颜色相同，那你不需要花费金币；如果不同，则你需要花费 1 个金币。 另外， 你可以花费 2个金币施展魔法让下一个无色格子暂时变为你指定的颜色。但这个魔法不能连续使用， 而且这个魔法的持续时间很短，也就是说，如果你使用了这个魔法，走
【人工智能导论】吃豆人游戏（上）：对抗搜索与Minimax算法
Pericles_HAT的博客
05-17 1万+
吃豆人实验（The Pac-Man Project）简介 The Pac-Man projects were developed for UC Berkeley’s introductory artificial intelligence course, CS 188. They apply an array of AI techniques to playing Pac-Man. The projects allow students to visualize the results of the te
Python 中用 300 行或更少的代码创建吃豆人游戏(教程含源码)
iCloudEnd的博客
12-27 1721
吃豆人是一款经典的平台游戏，今天可能已为所有人所熟知。“吃豆人”这个名字来自日语单词“paku”，意思是张开和合上嘴巴。创作者岩谷彻 (Toru Iwatani) 的灵感来自日本的一个故事，故事讲述的是一种生物通过吃掉怪物来保护儿童免受怪物伤害。在创作游戏时，他以故事中的关键词为跳板，“吃”这个动词成为一切的基础。怪物被表示为四个连续攻击玩家的幽灵，类似于太空侵略者。每个幽灵也有独特的个性。在故事中，还有一个更重要的元素，即生命力概念“可可罗”，它允许生物吃掉怪物。
解析吃豆人游戏
weixin_45771864的博客
05-22 1万+
【人工智能导论】解析吃豆人游戏 Q1: Reflex Agent Q2: Minimax Q3: Alpha-Beta Pruning Q4: Evaluation Function
Project 1：Search in Pacman（吃豆人搜索实验）（一）
HerstonG的博客
11-16 6928
题目链接http://ai.berkeley.edu/search.htmlQ1: Depth First SearchQ2: Breadth First SearchQ3: Uniform Cost SearchQ4: A* Search测试结果 由于能力有限，并没有做到满分。最终成绩为23/25 先更前四个题目，后四个题目陆续更新。 Q1: Depth First Search 第一个问题是需要实现深度优先搜索算法，选择利用util.py文件中已经定义好的Stack结构实现。Stack结构实现了一个后进
Leetcode:面试题47. 礼物的最大价值(动态规划）
stackempty2的博客
06-11 396
在一个 m*n 的棋盘的每一格都放有一个礼物，每个礼物都有一定的价值（价值大于 0）。你可以从棋盘的左上角开始拿格子里的礼物，并每次向右或者向下移动一格、直到到达棋盘的右下角。给定一个棋盘及其上面的礼物的价值，请计算你最多能拿到多少价值的礼物？ 示例 1: 输入: [ [1,3,1], [1,5,1], [4,2,1] ] 输出: 12 解释: 路径 1→3→5→2→1 可以拿到最多价值的礼物 提示： 0 < grid.length <= 200 0 < grid[0].length &l
前端实现简易吃豆人小游戏
ZunXin_2580的博客
01-24 1682
1、首先先将html文件里的初始代码设置完毕 2、规定范围 规定人物的活动范围，豆子的起始位置，人物的大小，并且逐次进行样式的编写 技术范围：css、html。 难点：需要在脑海中构思下一步的操作。 注意事项：外层盒子需要是相对定位，这样才能让豆子和人物有一个位置 3、绑定事件以及设定豆子的随机出现点 绑定事件以及设定豆子的随机出现点，要求是在人物移动时将豆子随机放在盒子中的某个地方。还有需要创建代表移动速度的全局变量，以及记录方向，豆子的在x、y轴上的方向也要记录 难点： 理解随机数以及对事件的绑定。
python 吃豆人_pacman 人工智能编程 吃豆人小游戏 可实现智能寻路 吃豆 通关 - 下载 - 搜珍网...
weixin_39640904的博客
12-04 693
Berkeley人工智能吃豆人作业-Python/Berkeley人工智能吃豆人作业-Python/再附带一份完整工程源码吧/Berkeley人工智能吃豆人作业-Python/再附带一份完整工程源码吧/Eclipse-python工作环境.txtBerkeley人工智能吃豆人作业-Python/再附带一份完整工程源码吧/PySearch/Berkeley人工智能吃豆人作业-Python/再附带一份...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值