再解炸弹人--广度搜索和深度搜索

最新推荐文章于 2022-03-15 20:17:59 发布
原创 最新推荐文章于 2022-03-15 20:17:59 发布 · 659 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#搜索 #bfs #dfs #炸弹人 #学习笔记

本文介绍了一种基于广度优先搜索（BFS）和深度优先搜索（DFS）的方法来解决炸弹人游戏中消灭敌人的问题。从初始位置出发，通过BFS或DFS遍历地图上可达的空地，并统计在每个可达位置放置炸弹能消灭的敌人数量。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

再解炸弹人

要求

之前炸弹人通过枚举统计每个点消灭敌人数，包括了小人不能直接到达的位置，现在要求小人从（3，3）位置开始，有敌人的地方小人不能通过，统计消灭敌人数。

思路

先使用广度优先搜索或者深度优先搜索找出小人可以通过的点，再统计这些点消灭敌人数

bfs代码

#include <stdio.h>

#define N 13
#define M 13

char a[13][13] = {
                    "#############",
                    "#GG.GGG#GGG.#",
                    "###.#G#G#G#G#",
                    "#.......#..G#",
                    "#G#.###.#G#G#",
                    "#GG.GGG.#.GG#",
                    "#G#.#G#.#.#.#",
                    "##G...G.....#",
                    "#G#.#G###.#G#",
                    "#...G#GGG.GG#",
                    "#G#.#G#G#.#G#",
                    "#GG.GGG#G.GG#",
                    "#############"
                  };

int b[13][13] = {0};

struct node 
{
    int x;
    int y;
};

struct node que[401];  // 地图大小不超过20*20
int head = 0, tail = 0;

void enqueue(struct node p) {
    que[tail] = p;
    tail++;
}

struct node dequeue() {
    head++;
    return que[head-1];
}

int is_empty() {
    return head == tail;
}

void print_a() {
    for (int i = 0; i < N; ++i)
    {
        for (int j = 0; j < M; ++j)
        {
            printf("%c ", a[i][j]);
        }
        printf("\n");
    }
    printf("\n");
}

void print_b() {
    for (int i = 0; i < N; ++i)
    {
        for (int j = 0; j < M; ++j)
        {
            printf("%d ", b[i][j]);
        }
        printf("\n");
    }
    printf("\n");
}

int main() 
{
    int i, j;
    struct node p = {3, 3}; // 小人所在位置
    enqueue(p);
    a[p.x][p.y] = '2'; // 小人到达点标记为2

    while(!is_empty()) {
        p = dequeue();

        // 统计此处安放炸弹消灭敌人数
        i = p.x;
        j = p.y;
        while(a[i][j] != '#') {  //right
            j++;
            if(a[i][j] == 'G') {
                b[p.x][p.y]++;
            }
        }

        i = p.x;
        j = p.y;
        while(a[i][j] != '#') {  //down
            i++;
            if(a[i][j] == 'G') {
                b[p.x][p.y]++;
            }
        }

        i = p.x;
        j = p.y;
        while(a[i][j] != '#') {  //left
            j--;
            if(a[i][j] == 'G') {
                b[p.x][p.y]++;
            }
        }

        i = p.x;
        j = p.y;
        while(a[i][j] != '#') {  // up
            i--;
            if(a[i][j] == 'G') {
                b[p.x][p.y]++;
            }
        }

        // bfs 搜索小人可以到达的点
        if (a[p.x][p.y+1] == '.') {
            struct node temp = {p.x, p.y+1};
            enqueue(temp);
            a[p.x][p.y+1] = '2';
        }

        if (a[p.x+1][p.y] == '.') {
            struct node temp = {p.x+1, p.y};
            enqueue(temp);
            a[p.x+1][p.y] = '2';
        }

        if (a[p.x][p.y-1] == '.') {
            struct node temp = {p.x, p.y-1};
            enqueue(temp);
            a[p.x][p.y-1] = '2';
        }

        if (a[p.x-1][p.y] == '.') {
            struct node temp = {p.x-1, p.y};
            enqueue(temp);
            a[p.x-1][p.y] = '2';
        }
    }

    print_a();
    print_b();

    return 0;
}

dfs代码

#include <stdio.h>

#define N 13
#define M 13

char a[13][13] = {
                    "#############",
                    "#GG.GGG#GGG.#",
                    "###.#G#G#G#G#",
                    "#.......#..G#",
                    "#G#.###.#G#G#",
                    "#GG.GGG.#.GG#",
                    "#G#.#G#.#.#.#",
                    "##G...G.....#",
                    "#G#.#G###.#G#",
                    "#...G#GGG.GG#",
                    "#G#.#G#G#.#G#",
                    "#GG.GGG#G.GG#",
                    "#############"
                  };

int b[13][13] = {0};

struct node 
{
    int x;
    int y;
};

struct node stack[41];
int top = 0;

void push(struct node p) {
    stack[top] = p;
    top++;
}

struct node pop() {
    top--;
    return stack[top];
}

int is_empty() {
    return top == 0;
}

void print_a() {
    for (int i = 0; i < N; ++i)
    {
        for (int j = 0; j < M; ++j)
        {
            printf("%c ", a[i][j]);
        }
        printf("\n");
    }
    printf("\n");
}

void print_b() {
    for (int i = 0; i < N; ++i)
    {
        for (int j = 0; j < M; ++j)
        {
            printf("%d ", b[i][j]);
        }
        printf("\n");
    }
    printf("\n");
}

int main() 
{
    int i, j;
    struct node p = {3, 3}; // 小人所在位置
    push(p);
    a[p.x][p.y] = '2';

    while(!is_empty()) {
        p = pop();

        // 统计此处安放炸弹消灭敌人数
        i = p.x;
        j = p.y;
        while(a[i][j] != '#') {  //right
            j++;
            if(a[i][j] == 'G') {
                b[p.x][p.y]++;
            }
        }

        i = p.x;
        j = p.y;
        while(a[i][j] != '#') {  //down
            i++;
            if(a[i][j] == 'G') {
                b[p.x][p.y]++;
            }
        }

        i = p.x;
        j = p.y;
        while(a[i][j] != '#') {  //left
            j--;
            if(a[i][j] == 'G') {
                b[p.x][p.y]++;
            }
        }

        i = p.x;
        j = p.y;
        while(a[i][j] != '#') {  // up
            i--;
            if(a[i][j] == 'G') {
                b[p.x][p.y]++;
            }
        }

        // bfs 搜索小人可以到达的点
        if (a[p.x][p.y+1] == '.') {
            struct node temp = {p.x, p.y+1};
            push(temp);
            a[p.x][p.y+1] = '2';
        }

        if (a[p.x+1][p.y] == '.') {
            struct node temp = {p.x+1, p.y};
            push(temp);
            a[p.x+1][p.y] = '2';
        }

        if (a[p.x][p.y-1] == '.') {
            struct node temp = {p.x, p.y-1};
            push(temp);
            a[p.x][p.y-1] = '2';
        }

        if (a[p.x-1][p.y] == '.') {
            struct node temp = {p.x-1, p.y};
            push(temp);
            a[p.x-1][p.y] = '2';
        }

    }
    print_a();
    print_b();

    return 0;
}

结果

# # # # # # # # # # # # #
# G G 2 G G G # G G G . #
# # # 2 # G # G # G # G #
# 2 2 2 2 2 2 2 # . . G #
# G # 2 # # # 2 # G # G #
# G G 2 G G G 2 # 2 G G #
# G # 2 # G # 2 # 2 # 2 #
# # G 2 2 2 G 2 2 2 2 2 #
# G # 2 # G # # # 2 # G #
# 2 2 2 G # G G G 2 G G #
# G # 2 # G # G # 2 # G #
# G G 2 G G G # G 2 G G #
# # # # # # # # # # # # #

0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 5 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0
0 3 0 0 0 2 0 1 0 0 0 0 0
0 0 0 0 0 0 0 1 0 0 0 0 0
0 0 0 5 0 0 0 6 0 5 0 0 0
0 0 0 0 0 0 0 1 0 3 0 8 0
0 0 0 2 2 5 0 3 2 5 2 10 0
0 0 0 0 0 0 0 0 0 3 0 0 0
0 4 1 1 0 0 0 0 0 8 0 0 0
0 0 0 0 0 0 0 0 0 3 0 0 0
0 0 0 5 0 0 0 0 0 6 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0
python 代码
N = 13
M = 13

a  =   ["#############",
        "#GG.GGG#GGG.#",
        "###.#G#G#G#G#",
        "#.......#..G#",
        "#G#.###.#G#G#",
        "#GG.GGG.#.GG#",
        "#G#.#G#.#.#.#",
        "##G...G.....#",
        "#G#.#G###.#G#",
        "#...G#GGG.GG#",
        "#G#.#G#G#.#G#",
        "#GG.GGG#G.GG#",
        "#############"]

b = [([0] * N) for i in range(N)]

q = []
s = []


def mprint(x):
    for i in range(N):
        print(x[i])


def marking(a, i, j):
    text = a[i]
    new = text[:j] + "2" + text[j+1:]
    a[i] = new


def bfs(i, j):
    q.append((i, j))
    marking(a, i, j)
    while len(q) != 0:
        i, j = q.pop(0)

        x = i
        y = j
        while a[x][y] != '#':  # right
            y = y + 1
            if a[x][y] == 'G':
                b[i][j] = b[i][j] + 1

        x = i
        y = j
        while a[x][y] != '#':  # down
            x = x + 1
            if a[x][y] == 'G':
                b[i][j] = b[i][j] + 1

        x = i
        y = j
        while a[x][y] != '#':  # left
            y = y - 1
            if a[x][y] == 'G':
                b[i][j] = b[i][j] + 1

        x = i
        y = j
        while a[x][y] != '#':  # up
            x = x - 1
            if a[x][y] == 'G':
                b[i][j] = b[i][j] + 1

        if a[i][j+1] == '.':
            q.append((i, j+1))
            marking(a, i, j+1)

        if a[i+1][j] == '.':
            q.append((i+1, j))
            marking(a, i+1, j)

        if a[i][j-1] == '.':
            q.append((i, j-1))
            marking(a, i, j-1)

        if a[i-1][j] == '.':
            q.append((i-1, j))
            marking(a, i-1, j)

    mprint(a)
    mprint(b)


def dfs(i, j):
    s.append((i, j))
    marking(a, i, j)

    while len(s):
        i, j = s.pop()

        x = i
        y = j
        while a[x][y] != '#':  # right
            y = y + 1
            if a[x][y] == 'G':
                b[i][j] = b[i][j] + 1

        x = i
        y = j
        while a[x][y] != '#':  # down
            x = x + 1
            if a[x][y] == 'G':
                b[i][j] = b[i][j] + 1

        x = i
        y = j
        while a[x][y] != '#':  # left
            y = y - 1
            if a[x][y] == 'G':
                b[i][j] = b[i][j] + 1

        x = i
        y = j
        while a[x][y] != '#':  # up
            x = x - 1
            if a[x][y] == 'G':
                b[i][j] = b[i][j] + 1

        if a[i][j + 1] == '.':
            s.append((i, j + 1))
            marking(a, i, j + 1)

        if a[i + 1][j] == '.':
            s.append((i + 1, j))
            marking(a, i + 1, j)

        if a[i][j - 1] == '.':
            s.append((i, j - 1))
            marking(a, i, j - 1)

        if a[i - 1][j] == '.':
            s.append((i - 1, j))
            marking(a, i - 1, j)

    mprint(a)
    mprint(b)

# bfs(3, 3)
dfs(3, 3)

总结

bfs使用队列实现，dfs使用栈实现，将bfs中的队列改为栈就很容易写出dfs。

第4章第4节-再解炸弹人-深度优先搜索
越努力越幸运！
04-13 312
/*广度优先搜索解炸弹人*/ /*#表示墙、G表示敌人、.表示空地 问炸弹放在那个位置才可以消灭最多的敌人 示例输入： 13 13 3 3 ############# #GG.GGG#GGG.# ###.#G#G#G#G# #.......#..G# #G#.###.#G#G# #GG.GGG.#.GG# #G#.#G#.#.#.# ...
啊哈算法炸弹人游戏----深度优先搜索与广度优先搜索
Jared的博客
07-08 979
1.问题描述：在炸弹人游戏中，你有一颗炸弹，该炸弹的威力是十字形的，即只能爆出上下左右型的火焰，且火焰不能穿墙，问应该将炸弹放到哪里炸弹才能杀死最多的小怪？（注：该位置必须是炸弹人能有初始位置走到的位置，毕竟炸弹人不能飞，墙或者小怪都能阻挡炸弹人的路径），现在游戏地图如下图所示，炸弹人的位置在（3,3）处。 2.解题思路：需要先将问题抽象出来，我们可以用一个 二维数组 来表示 游戏地图...
再解炸弹人-bfs
qq_42912469的博客
03-03 696
问题描述 代码解决 #include <stdio.h> char a[21][21];//用来存储地图 struct node { int x;//横坐标 int y;//纵坐标 }; int getnum(int x,int y) {// int num=0;//用来计数 int tx, ty; //从四个方向统计可以消灭的敌人 //向右 tx = x; ty = y; while (a[tx][ty] != '#') {//判断是不是墙，不是墙继续 if
再解炸弹人(bfs)
weixin_30335575的博客
02-03 259
题目描述(ID:12034) 标题: 再解炸弹人(bfs) 标签: 搜索深度优先搜索广度优先搜索 详情: 现在炸弹不是想放在那里就能放在那里的了，必须由小人能够走到的地方才能放置炸弹。比如下面这个例子小人默认站在(3,3)这个位置。请问放在何处最多可以消灭多个敌人。 输入格式: 第一行4个整数为n m x y，分别n和m...
再解炸弹人
baidu_34872357的博客
05-14 549
#include struct note { int x;//横坐标 int y;//纵坐标 }; char a[20][21];//用来存储地图 int getnum(int i,int j) { int sum,x,y; sum=0;//sum用来计数消灭的敌人，所以每次要初始化 //将坐标i,j复制到两个新的变量x,y中，便于想上下左右统计可以消灭的敌
再解炸弹人（bfs-dfs）
Koutoto的博客
03-15 196
题出自啊哈算法P95 bfs算法 #include <iostream> #include <queue> using namespace std; char a[100][100]; int book[100][100]; int sx,sy,n,m,dx,dy,res=0; int inext[4][2]= {{0,1},{1,0},{0,-1},{-1,0}}; struct node { int x,y; }; void getsum(int x,int y) {
再解炸弹人-dfs
qq_42912469的博客
03-04 4235
问题描述 见炸弹人游戏—bfs | halisi7。 代码实现 #include <stdio.h> char a[21][21]; int book[20][20] = { 0 };//初始值为0，表示没走过的路径 int n,m, max = 0, sum = 0 , mx, my ; int getnum(int x, int y) {// int num = 0;//用来计数 int tx, ty; //从四个方向统计可以消灭的敌人 //向右 tx = x; ty = y;
js实现广度优先搜索和深度优先搜索
ChenyiMX的博客
11-13 1791
最近在学习算法，看了图解算法，但是感觉写的太简单，理论比较多，代码实现比较和例子比较少，看完后，又接着看了《啊哈！算法》，这个感觉例子比较多，也比较适合我这种算法入门的读者。 书上的例子一一打了一遍，因为作者是用c写的，而我是没接触过c，用了自己比较熟悉的js把例子打了一遍。用广搜写了贪吃蛇自动吃果实，只能吃100多个，自认为还能完善，于是等完善后在放在博客上面吧。 这里先写写用dfs（深搜） 和...
炸弹人
02-21
"炸弹人"是一款经典的街机游戏，以其独特的对战模式和策略性深受玩家喜爱。在IT行业中，"炸弹人"的实现通常涉及到游戏开发、图形界面设计、网络编程以及算法应用等多个方面。在这个项目中，标签"Java"表明了它是用...
炸弹人 广度优先—C
cheryl_77的博客
08-30 562
二维地图，找出哪一点可以炸最多的敌人，使用广度优先遍历每个可达点，计算每个点可以炸的敌人数，找出最多的那个点.
炸弹超人，C语言编写。
05-22
炸弹超人，C语言编写。
c# 游戏实例 炸弹人 源码（大学时期作品）
06-20
本人大学时期作品，在其他地方绝对找不到，源码，有注释。
再解炸弹人（深度优先和广度优先）
qq_40761693的博客
02-08 697
现在炸弹不是想放在那里就能放在那里的了，必须由小人能够走到的地方才能放置炸弹。比如下面这个例子小人默认站在(3,3)这个位置。请问放在何处最多可以消灭多个敌人。 解释：上面解炸弹人的方法有可能小人并不能走到那里去，也就不能放置炸弹。我们可以通过深度优先和广度优先来进行搜索，确保该点小人可以到达，再在可到达的点周围确定可以消灭敌人的数目。 dfs：先更新最大值，再循环 #include &lt...
再解炸弹人--地图--bfs搜素
Nicolas的博客
12-22 455
标题: 再解炸弹人 标签: 搜索 深度优先搜索 广度优先搜索 详情: 现在炸弹不是想放在那里就能放在那里的了，必须由小人能够走到的地方才能放置炸弹。比如下面这个例子小人默认站在(3,3)这个位置。请问放在何处最多可以消灭多个敌人。 输入格式: 第一行4个整数为n m x y，分别n和m表示迷宫的行和列，x和y表示小人的起始坐标（从0行0列开始计算），接...
4.4.1再解炸弹人（DFSearch）
shaguabufadai的博客
03-13 661
#include using namespace std; char a[21][21];//用来存储地图 int book[21][21]={0};//定义一个标记数组并全部初始化为0 int Max,mx,my,n,m; int getnum(int i,int j){ int num,x,y; int sum=0;//sum用来计数(可以消灭的敌人数)，所以需要初始化为0 //将
啊哈算法搜索应用之再解炸弹人(DFS与BFS)
不忘初心
10-04 1404
//广搜 #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 891
昨晚在工作室看书看得太累了，绕小房间走了一圈之后发现了一本神奇的书：《啊哈！算法》 哈哈，之前在买《算法导论》之前还想买一本这个来补救我没听一学期的算法基础课 就这样拖着拖着给忘了，真是糟糕呐 这本书还是相当有趣的，不比学校发的那些个无聊的课本，看都不想看，我一下子就想把整本书给看完，但是精力实在是有限呀，只能靠我所剩不多的数学知识一点点慢慢看 这期间，最让我感兴趣的是炸弹人这一个算法的多
炸弹人（广度优先搜索)
Be Like
06-15 745
首先用广度优先搜索来枚举出所有小人能够到达的点，并计算出每个点能够消灭的敌人的数量。如果下一个点能够消灭的敌人数量大于前一个，那么更新消灭敌人数量的最大值，并更新坐标点。下面是代码。 #include #include #include using namespace std; struct A { int x,y; }; int Next[4][2] = {{0,1},{1,0}
BFS深度优先搜索 炸弹人
一个小孩的自我踌躇
04-23 461
题面：一个人在一个坐标放炸弹，请问可以可以杀死的敌人数目最大是，并且输出该点的坐标 G代表敌人 .代表该位置可以走 “#”代表该位置存在障碍物 并且防止炸弹的蔓13 13 3 3 .############# .#GG.GGG#GGG.# .###.#G#G#G#G# .#…….#..G# .#G#.###.#G#G# .#GG.GGG.#.GG# .#G#.#G#.#.#.#
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值