撕烂数据爆锤算法：广度、深度优先搜索例题之炸弹人

最新推荐文章于 2022-04-04 19:41:43 发布
最新推荐文章于 2022-04-04 19:41:43 发布
阅读量435 收藏 1
点赞数 2
分类专栏： 撕烂数据爆锤算法 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45714923/article/details/107417995
版权

啰啰嗦嗦

理解知识最有效的方式之一就是多刷题，在解题的过程中我们可能会更加容易记忆和理解知识点，我们能够了解到其在题目中的具体运用方式。通过实打实的上手编程，带来的好处不言而喻。如果你仅限于从书中看懂或者从教学视频中听懂，而不亲手去实现它，这些知识很难被真正的掌握。当你一字一字地完整地码下来时，你会发现其实有很多错误是你平时学习的时候注意不到的。只有经过大量实战练习，你才会对自己的不足有所了解。当然，小编也是刚学习不久，若有什么不足之处，还望各位大佬海涵啦！
同是天涯码字猿，
共勉，共勉~~~

在这里插入图片描述

题干

炸弹人小鑫拥有一个威力巨大的炸弹，它能炸掉其上、下、左、右四个方向上的所有气球，但是不能炸掉坚硬的墙壁。现在小鑫正处于一个高n，宽m的地图里，地图中有墙、空地和气球（规定用1表示墙，0表示空地，2表示气球）。小鑫只能在空地上行走，且只能向上下左右四个方向行走，更不可走出地图边界。试问小鑫应该把炸弹安放在何处，才能使炸弹炸掉的气球数最多呢？发挥你的聪明才智，帮帮小鑫吧！（注：炸弹只能放在空地上）

输入：
第一行输入n（0<n<100）,m（0<m<100）
输入n行每行m个（0或1或2）分别用来表示空地、墙、气球

输出：
炸弹应该安放在: 位置坐标（x，y） 炸掉气球数为: 整数

输入示例：
13 13
1 1 1 1 1 1 1 1 1 1 1 1 1
1 2 2 0 2 2 2 1 2 2 2 0 1
1 1 1 0 1 2 1 2 1 2 1 2 1
1 0 0 0 0 0 0 0 1 0 0 2 1
1 2 1 0 1 1 1 0 1 2 1 2 1
1 2 2 0 2 2 2 0 1 0 2 2 1
1 2 1 0 1 2 1 0 1 0 1 1 1
1 1 2 0 0 0 2 0 0 0 0 0 1
1 2 1 0 1 2 1 1 1 0 1 2 1
1 0 0 0 2 1 2 2 2 0 2 2 1
1 2 1 0 1 2 1 2 1 0 1 2 1
1 2 2 0 2 2 2 1 2 0 2 2 1
1 1 1 1 1 1 1 1 1 1 1 1 1
5 4

输出示例：
炸弹应该安放在: (10,10) 炸掉气球数为: 8

解法一：广度优先搜索

（C++实现）

定义头文件

//头文件
#include<iostream>
using namespace std;

宏定义

//宏定义
#define UNDEFIND -231231       //不存在的数
#define MAX_NODE_NUM 100       //标记位置数量的最大值
#define MAX_MAP_SIZE 100       //地图宽和高的最大值
#define MAX_KEEPNODE_NUM 100   //保存位置信息数的最大值

定义炸弹人类

typedef class Node{//炸弹人类，用于表示炸弹人及炸弹相关信息

friend class NodeQueue; //设置类友元

//属性
private:
	int x;  //炸弹人的x坐标
	int y;  //炸弹人的y坐标
	int over_num;  //炸弹炸掉气球的个数
	Node* next;    //指向下一位置信息的指针

//方法
public:
	Node(){//构造函数，初始化属性
		this->x=UNDEFIND;
		this->y=UNDEFIND;
		over_num=UNDEFIND;
		next=NULL;
	}

	Node(int x,int y,int num){//构造函数，给属性赋值
		this->x=x;
		this->y=y;
		over_num=num;
		next=NULL;
	}

	int getX(){//返回x坐标
		return x;
	}

	int getY(){//返回y坐标
		return y;
	}

	int getOverNum(){//返回炸掉气球个数
		return over_num;
	}

	void destory(){//销毁对象
		delete this;
	}
}Node,*Pnode;    //typedef用于取别名

定义队列类

int k=0;    //Keep数组的索引键值
Pnode Keep[MAX_KEEPNODE_NUM];   //保留所有炸弹人能到达且能安放炸弹的位置的信息

typedef class NodeQueue{//队列类，用于暂时存储炸弹人走过且能安放炸弹的位置的信息

//属性
private:
	Pnode head;  //队头
	Pnode last;  //队尾

public:
	NodeQueue(){//构造函数，初始化队头、队尾结点
		last=head=new Node();
	}

	bool isEmpty(){//判断队列是否为空
		return head->next==NULL;
	}

	void add(int x,int y,int num){//入队
		Pnode N;
		N=new Node(x,y,num);
		Keep[k++]=new Node(x,y,num); //将位置信息存入Keep数组
		last->next=N;
		last=N;
		return;
	}

	Pnode remove(){//出队
		Pnode h,g;
		h=head->next;
		g=new Node(h->getX(),h->getY(),h->getOverNum());
		head->next=h->next;
		if(head->next==NULL)
			last=head;
		delete h;
		return g;
	}
	void destory(){//销毁队列
		delete head;
	}
}NQueue,*Pqueue;

定义游戏操作类

class BombMan{//游戏操作类，用于设置地图、实施安放炸弹相关操作

//属性
private:
	int n;   //地图高度
	int m;   //地图宽度
	int Next[4][2];  //炸弹人行走方向，上->右->下->左
    int Map[MAX_MAP_SIZE][MAX_MAP_SIZE];   //地图数组，值为1表示墙，0表示空地，2表示气球
    int Sign[MAX_NODE_NUM][MAX_NODE_NUM];  //标记数组，用来标记位置信息，值为1表示该位置已经走过，为0表示未走过

//私有方法
private:
    void destoryKeep(){//销毁keep数组中的所有结点
	    int i;
	    for(i=0;i<k-1;i++)
		    Keep[i]->destory();
	    return;
	}

    int getOverNums(int x,int y){//返回炸弹安放在（x,y）时，能炸掉的气球数
		int i,j,num;
	    num=0;
		//记录各个方向上能炸掉的气球数
	    for(i=x-1,j=y;i>0 && (Map[i][j]==2 || Map[i][j]==0);i--)//向上
		    if(Map[i][j]==2)
			    num++;
	    for(i=x,j=y+1;j<=m && (Map[i][j]==2 || Map[i][j]==0);j++)//向右
		    if(Map[i][j]==2)
		        num++;
	    for(i=x+1,j=y;i<=n && (Map[i][j]==2 || Map[i][j]==0);i++)//向下
		    if(Map[i][j]==2)
		        num++;
	    for(i=x,j=y-1;j>0 && (Map[i][j]==2 || Map[i][j]==0);j--)//向左
		    if(Map[i][j]==2)
		        num++;
	    return num;
	}

//公共方法
public:
	BombMan(){//初始化Sign数组和Keep数组
		int i,j;
		for(i=0;i<MAX_NODE_NUM;i++)
			for(j=0;j<MAX_NODE_NUM;j++)
		        Sign[i][j]=0;
		Next[0][0]=-1;
		Next[0][1]=0;
		Next[1][0]=0;
		Next[1][1]=1;
		Next[2][0]=1;
		Next[2][1]=0;
		Next[3][0]=0;
		Next[3][1]=-1;
	}

	void createMap(){//创建地图
	    int i,j;
	    cin>>n>>m;
	    for(i=1;i<=n;i++)
		    for(j=1;j<=m;j++)
			    cin>>Map[i][j];
	    return;
	}
	
    void setStartPlace(){//设置起始点
	    Pnode N;
	    int x,y,num;
	    cin>>x>>y;
	    if(x<1 || x>n || y<1 || y>m)
		{
		    cout<<endl<<"起始地点值有误，游戏结束！"
			    <<endl<<endl;
		    exit(-1);
		}
	    else if(Map[x][y]!=0)
		{
		    cout<<endl<<"起始地点不是空地，游戏结束！"
			    <<endl<<endl;
		    exit(-1);
		}
	    num=getOverNums(x,y);
	    N=new Node(x,y,num);
	    Keep[k++]=N;   //将炸弹人起始位置信息保存在Keep数组中
	    Sign[x][y]=1;  //该位置标记走过
	    return;
	}
	
    void layBomb(){//通过广度优先搜索，炸弹人走一遍每个能走到的位置   （算法核心）
	    Pnode h;
	    Pqueue Q;
	    int i,num,tx,ty;
	    Q=new NQueue();
	    num=getOverNums(Keep[k-1]->getX(),Keep[k-1]->getY());
	    Q->add(Keep[k-1]->getX(),Keep[k-1]->getY(),num);      //将起始点位置信息入队
	    while(!Q->isEmpty())
		{
		    h=Q->remove();  //出队，得到炸弹人当前位置信息
		    for(i=0;i<4;i++)//炸弹人下一步行走的四个方向，都尝试走一遍，能走则将这个方向的位置入队
			{
				//得到下一步位置
			    tx=h->getX()+Next[i][0];
			    ty=h->getY()+Next[i][1];
			    if(tx<1 || tx>n || ty<1 || ty>m)  //判断炸弹人下一步位置是否越界，越界则进入另外方向的行走
				    continue;
			    if(Map[tx][ty]==0 && Sign[tx][ty]==0)  //判断炸弹人下一步位置是否能走（需未被标记且是空地）
				{
				    Sign[tx][ty]=1;  //该位置标记走过
				    num=getOverNums(tx,ty);  
				    Q->add(tx,ty,num);   //将该位置入队
				}
			}
		}
	    Q->destory();
	    return;
	}

    void getMaxOverNumNode(){//找到炸弹能炸掉最多气球的安放点，并输出结果
		int i,pos;
	    pos=0;
	    for(i=1;i<k;i++)
		    if(Keep[pos]->getOverNum()<Keep[i]->getOverNum())
			    pos=i;
	    cout<<endl<<"炸弹应该安放在: ("
		    <<Keep[pos]->getX()<<","<<Keep[pos]->getY()<<") "
		    <<" 炸掉气球数为: "<<Keep[pos]->getOverNum()
		    <<endl<<endl;
	    destoryKeep();
	    return;
    }

	void destory(){//销毁对象
		delete this;
	}
};

测试函数

//测试
void Test()
{
	BombMan* B=new BombMan();
	B->createMap();
	B->setStartPlace();
	B->layBomb();
	B->getMaxOverNumNode();
	B->destory();
	return;
}

int main()
{
	Test();
	system("pause");
	return 0;
}

运行结果
运行结果

解法二：深度优先搜索

（大致步骤与解法一类似，请先理解解法一）

定义头文件

//头文件
#include<iostream>
using namespace std;

宏定义

//宏定义
#define UNDEFIND -231231       //不存在的数
#define MAX_NODE_NUM 100       //标记位置数量的最大值
#define MAX_MAP_SIZE 100       //地图宽和高的最大值
#define MAX_KEEPNODE_NUM 100   //保存位置信息数的最大值

定义炸弹人类

typedef class Node{//炸弹人类，用于表示炸弹人及炸弹相关信息

friend class NodeQueue; //设置类友元

//属性
private:
	int x;  //炸弹人的x坐标
	int y;  //炸弹人的y坐标
	int over_num;  //炸弹炸掉气球的个数
	Node* next;    //指向下一位置信息的指针

//方法
public:
	Node(){//构造函数，初始化属性
		this->x=UNDEFIND;
		this->y=UNDEFIND;
		over_num=UNDEFIND;
		next=NULL;
	}

	Node(int x,int y,int num){//构造函数，给属性赋值
		this->x=x;
		this->y=y;
		over_num=num;
		next=NULL;
	}

	int getX(){//返回x坐标
		return x;
	}

	int getY(){//返回y坐标
		return y;
	}

	int getOverNum(){//返回炸掉气球个数
		return over_num;
	}

	void destory(){//销毁对象
		delete this;
	}
}Node,*Pnode;

定义游戏操作类

int k=0;
Pnode Keep[MAX_KEEPNODE_NUM];

class BombMan{
private:
	int n;
	int m;
	int Next[4][2];
    int Map[MAX_MAP_SIZE][MAX_MAP_SIZE];
    int Sign[MAX_NODE_NUM][MAX_NODE_NUM];

private:
	void destoryKeep(){
	    int i;
	    for(i=0;i<k-1;i++)
		    Keep[i]->destory();
	    return;
	}

	int getOverNums(int x,int y){
		int i,j,num;
	    num=0;
	    for(i=x-1,j=y;i>0 && (Map[i][j]==2 || Map[i][j]==0);i--)
		    if(Map[i][j]==2)
			    num++;
	    for(i=x,j=y+1;j<=m && (Map[i][j]==2 || Map[i][j]==0);j++)
		    if(Map[i][j]==2)
		        num++;
	    for(i=x+1,j=y;i<=n && (Map[i][j]==2 || Map[i][j]==0);i++)
		    if(Map[i][j]==2)
		        num++;
	    for(i=x,j=y-1;j>0 && (Map[i][j]==2 || Map[i][j]==0);j--)
		    if(Map[i][j]==2)
		        num++;
	    return num;
	}

public:
	BombMan(){
		int i,j;
		for(i=0;i<MAX_NODE_NUM;i++)
			for(j=0;j<MAX_NODE_NUM;j++)
		        Sign[i][j]=0;
		Next[0][0]=-1;
		Next[0][1]=0;
		Next[1][0]=0;
		Next[1][1]=1;
		Next[2][0]=1;
		Next[2][1]=0;
		Next[3][0]=0;
		Next[3][1]=-1;
	}

	void createMap(){
	    int i,j;
	    cin>>n>>m;
	    for(i=1;i<=n;i++)
		    for(j=1;j<=m;j++)
			    cin>>Map[i][j];
	    return;
	}

    void setStartPlace(){
	    Pnode N;
	    int x,y,num;
	    cin>>x>>y;
	    if(x<1 || x>n || y<1 || y>m)
		{
		    cout<<endl<<"起始地点值有误，游戏结束！"
			    <<endl<<endl;
		    exit(-1);
		}
	    else if(Map[x][y]!=0)
		{
		    cout<<endl<<"起始地点不是空地，游戏结束！"
			    <<endl<<endl;
		    exit(-1);
		}
	    num=getOverNums(x,y);
	    N=new Node(x,y,num);
	    Keep[k++]=N;
	    Sign[x][y]=1;
	    return;
	}

	Pnode getKeepFirstNode(){
		return Keep[k-1];
	}

    void layBomb(Pnode h){//通过深度优先搜索，炸弹人走一遍每个能走到的位置   （算法核心）    
		Pnode p;
		int i,tx,ty,num;
    	for(i=0;i<4;i++)
		{
	 		tx=h->getX()+Next[i][0];
			ty=h->getY()+Next[i][1];
			if(tx<1 || tx>n || ty<1 || ty>m)
				continue;
			if(Map[tx][ty]==0 && Sign[tx][ty]==0)
			{
				Sign[tx][ty]=1;
				num=getOverNums(tx,ty);
			    p=new Node(tx,ty,num);
				Keep[k++]=p;//保存能走且能安放炸弹的位置信息
				layBomb(p);//递归调用，炸弹人移到这个方向上的下一步的位置
			}
		}
		return;
	}

    void getMaxOverNumNode(){
		int i,pos;
	    pos=0;
	    for(i=1;i<k;i++)
		    if(Keep[pos]->getOverNum()<Keep[i]->getOverNum())
			    pos=i;
	    cout<<endl<<"炸弹应该安放在: ("
		    <<Keep[pos]->getX()<<","<<Keep[pos]->getY()<<") "
		    <<" 炸掉气球数为: "<<Keep[pos]->getOverNum()
		    <<endl<<endl;
	    destoryKeep();
	    return;
    }

	void destory(){
		delete this;
	}

};

测试函数

//测试
void Test()
{
	BombMan* B=new BombMan();
	B->createMap();
	B->setStartPlace();
	B->layBomb();
	B->getMaxOverNumNode();
	B->destory();
	return;
}

int main()
{
	Test();
	system("pause");
	return 0;
}

运行结果
运行结果

文末

菜鸟小编带你撕烂数据锤爆算法，关于两种优先搜索算法的具体知识正在更新中，敬请期待！

小小推荐

撕烂数据爆锤算法系列：
单链表
循环链表
内排序之插入算法
内排序之交换算法

程序人生系列：
大一总结：一路走来，从迷茫到渴望

感谢浏览，你们的支持是我最大的动力，拜~~

.最小生成树
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
啊哈算法炸弹人游戏----深度优先搜索与广度优先搜索
Jared的博客
07-08 851
1.问题描述：在炸弹人游戏中，你有一颗炸弹，该炸弹的威力是十字形的，即只能爆出上下左右型的火焰，且火焰不能穿墙，问应该将炸弹放到哪里炸弹才能杀死最多的小怪？（注：该位置必须是炸弹人能有初始位置走到的位置，毕竟炸弹人不能飞，墙或者小怪都能阻挡炸弹人的路径），现在游戏地图如下图所示，炸弹人的位置在（3,3）处。 2.解题思路：需要先将问题抽象出来，我们可以用一个 二维数组 来表示 游戏地图...
Python数据结构与算法之图的广度优先与深度优先搜索算法示例
09-20
### Python数据结构与算法之图的广度优先与深度优先搜索算法详解 #### 一、引言 在计算机科学领域，图是一种非常重要的数据结构，它由一系列节点（顶点）以及连接这些节点的边组成。图可用于表示各种各样的问题，...
啊哈！算法—枚举之炸弹人
LY_624的专栏
05-02 2131
炸弹人： 现有关卡：游戏者只有一枚炸弹，且炸弹可以杀死杀伤范围内所有敌人。请问炸弹放在哪个位置，可以消灭最多的敌人。 思路：   首先将地图模型化。墙用#表示；敌人用G表示；空地用.表示。炸弹只能放在空地上。 如：13行13列 ############# #GG.GGG#GGG.# ###.#G#G#G#G# #.......#..G# #G#.###.#G#G# #GG.
啊哈算法：炸弹人
Greedy Hat的博客
04-14 614
/*用枚举法来初步解决炸弹人问题*/ #include<bits/stdc++.h> using namespace std; int main() { char a[100][100];//定义地图的大小 int sum; int map=0; int n,m; while(cin>>n>>m) { int x,y; //n代表行，...
搜索算法（二）--DFS/BFS求解炸弹人问题（JAVA ）
一串代码的博客
01-10 784
炸弹人问题 问题描述：小人可以在迷宫中任意地方放置一个炸弹，炸弹可以在以该点为中心的十字方向杀死怪物，但是触碰到墙之后不再能传递攻击。求将一个炸弹放在哪个位置可以杀死更多的怪物？？ Input： 13 13 ############# #GG.GGG#GGG.# ###.#G#G#G#G# #.......#..G# #G#.###.#G#G# #GG.GGG.#.GG# #G#
专项训练（BFS炸弹人-啊哈算法）
qq_40293424的博客
02-11 308
import java.util.Scanner; import java.util.Arrays; import java.util.Queue; import java.util.LinkedList; class bfs2{ int x; int y; } public class BFS炸弹人 { static int m,n,sx,sy,max=0,mx=0,my=0; s...
python基础编程：Python数据结构与算法之图的广度优先与深度优先搜索算法示例
12-22
本文将重点探讨图的两种遍历算法：广度优先搜索（BFS）和深度优先搜索（DFS），并提供Python实现示例。 **广度优先搜索（BFS）** BFS是一种用于遍历或搜索树或图的算法，它按照从根节点开始，逐层展开节点的方式...
基于Python的图搜索算法实现：广度优先搜索BFS，Dijkstra 算法，贪心最佳优先搜索，A*搜索
最新发布
04-19
该代码实现了广度优先搜索BFS，Dijkstra 算法，贪心最佳优先搜索，A*搜索，并提供了将搜索结果画图展示的接口。 在入口文件处，提供了如何调用各类算法的例子以及演示了使用画图接口的方法。
LinglingGreat#StudyAlgorithm#16【数据结构与算法】深度和广度优先搜索1
07-25
当我们访问到第 k 层的顶点的时候，我们需要把第 k 层的顶点记录下来，稍后才能通过第 k 层的顶点来找第 k+1 层的顶点。这个时候，每个顶点都要进出一遍队列
枚举 + 深度搜索 ----炸弹人
jiejiexiao的博客
01-29 174
package com.xjj.Ah; /*---枚举 + 深度搜索 ----炸弹人---- * 1. 炸弹能到达的地方最多能炸死的敌人数 * 2. 用枚举法来获得每个空格放置炸弹能炸死的敌人数，用深度搜索法来获得能达到的地方 * 3. 先沿着一个方向深度搜索，遇到墙，在将此点四个方向都遍历完就返回， * 4. book[][] 标记是否已经遍历 * * 5. 深度优先搜索关键：当
Java小游戏-炸弹人-课程设计-论文-AI
12-29
项目描述：https://blog.csdn.net/qq_34060370/article/details/115682618?spm=1001.2014.3001.5502 亮点：BFS算法实现电脑AI 完成像小时候玩的炸弹人游戏，或模仿4399小游戏中的泡泡堂 主要模块如下 游戏相关：换关卡、操作玩家、AI电脑、背景音乐、数值提升 游戏管理：重开、暂停/开始、退出、切换模式、音乐开关 关卡管理：关卡显示、关卡界面设计 知识点：BFS算法实现AI、数据结构、JavaSwing界面、paint绘图、线程
html5炸弹人游戏源码
02-02
html5炸弹人游戏源码、有自己炸弹和敌人还有地图墙壁等图片资源、有a*算法
Java-小游戏-炸弹人-课程设计-搜索算法
qq_34060370的博客
10-17 2810
完整的源码+完整的项目文档 如果对你又帮助，希望麻烦给github项目一个star和本视频一个赞 b站演示视频：https://www.bilibili.com/video/BV1Fx411R7yq/ 该项目作为大一下学期JAVA课程设计 亮点：BFS算法实现电脑AI 完成像小时候玩的炸弹人游戏，或模仿4399小游戏中的泡泡堂 主要模块如下 游戏相关：换关卡、操作玩家、AI电脑、背景音乐、数值提升 游戏管理：重开、暂停/开始、退出、切换模式、音乐开关 关卡管理：关卡显示、关卡界面设计 ...
啊哈算法之炸弹人（广度优先搜索）
asd11236852290的博客
04-04 625
直接上代码 本题关键是在队列的head tail 的理解，我个人是这样理解的：head每次对应的点位都是用来进行下一步的扩展的，而tail则负责存放被扩展出来的点，tail++是为了储存更多的点，而在while末尾才head++则是为了进行下一个点位的扩展。
炸弹人（深度优先搜索实现）
hnjzsyjyj的专栏
07-30 751
【问题描述】 “炸弹人”游戏有一个特殊的关卡如下： 你只有一枚炸弹，但是这枚炸弹的威力超强（杀伤距离超长，可以消灭杀伤范围内所有的敌人）。请问在哪里放置炸弹可以消灭最多的敌人呢？ 首先将“炸弹人”游戏地图模型化：墙用“#”表示，敌人用“G”表示，空地用“.”表示。 虽然墙有两种（一种可以炸掉，一种不可以炸掉），但是考虑到此问题中只有一枚炸弹，所以在将“炸弹人”游戏地图模型化时，墙都用“#”表示。因为炸弹不能穿墙，所以即便是能被炸掉的墙，位于其后的敌人也不能被杀死，不会对消灭敌人的总数产生影响。【...
学习《啊哈！算法》---暴力枚举--炸弹人篇 总结
qq_35917517的博客
01-05 825
文章目录前言一、原题二、分析1.建模2.解题思路3、遍历寻找附：关于边界问题总结 前言 《啊哈算法的》中第三章，在学习第三章《枚举！很暴力》中，读完炸弹人篇发现和自己曾经做的题是一个类型的。 发这篇blog也是感慨一下，曾经自己想了一下午且认为难过登天的题目，其实就是简单的算法模型。 当然，感到高兴的是，自己曾经琢磨出的思路、方法还是正确的，至少在学习甚少的情况下，居然自己琢磨出了这种“有地图”的题目的一般思路。 一、原题 以下是PDF版本的截图： 问题主要是 炸弹放在那里可以炸死更多的敌人。 二、分析
啊哈算法搜索应用之再解炸弹人(DFS与BFS)
不忘初心
10-04 1340
//广搜 #include #include #include struct node{//存此点的坐标，消灭敌人数 int x; int y; int sum; }; struct node queue[20];//队列实现BFS int head=0; int tail=0; char map[21][21];//存图 int book[21][21];//标记走
万能的搜索之再解炸弹人
周清城的博客
07-17 837
昨晚在工作室看书看得太累了，绕小房间走了一圈之后发现了一本神奇的书：《啊哈！算法》 哈哈，之前在买《算法导论》之前还想买一本这个来补救我没听一学期的算法基础课 就这样拖着拖着给忘了，真是糟糕呐 这本书还是相当有趣的，不比学校发的那些个无聊的课本，看都不想看，我一下子就想把整本书给看完，但是精力实在是有限呀，只能靠我所剩不多的数学知识一点点慢慢看 这期间，最让我感兴趣的是炸弹人这一个算法的多
炸弹人（广度优先搜索实现）
hnjzsyjyj的专栏
07-30 439
【问题描述】 “炸弹人”游戏有一个特殊的关卡如下： 你只有一枚炸弹，但是这枚炸弹的威力超强（杀伤距离超长，可以消灭杀伤范围内所有的敌人）。请问在哪里放置炸弹可以消灭最多的敌人呢？ 首先将“炸弹人”游戏地图模型化：墙用“#”表示，敌人用“G”表示，空地用“.”表示。 虽然墙有两种（一种可以炸掉，一种不可以炸掉），但是考虑到此问题中只有一枚炸弹，所以在将“炸弹人”游戏地图模型化时，墙都用“#”表示。因为炸弹不能穿墙，所以即便是能被炸掉的墙，位于其后的敌人也不能被杀死，不会对消灭敌人的总数产生影响。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值