搜索 （bfs，dfs） 总结

最新推荐文章于 2025-04-13 00:17:47 发布
最新推荐文章于 2025-04-13 00:17:47 发布
阅读量588 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 数据结构------搜索 总结
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/flyljg/article/details/38520349
本文深入探讨了游戏开发领域的关键技术，包括游戏引擎、编程语言、硬件优化等，并重点阐述了AI音视频处理的应用场景和实现方法，如语义识别、物体检测、语音变声等。

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

A - A
Time Limit:1000MS     Memory Limit:65536KB     64bit IO Format:%lld & %llu

Description

  话说 CZ 由于不守基道，被妖怪抓走了，好基友 WP 在努力讨好高富帅 RQ 救出 CZ 的同时， CZ 也意识到了自己的错误，然后努力的想逃出妖怪的闺房。 

Input

 每组测试数据的第一行有三个整数   n,m,t(2<=n,m<=20,t>0)。接下来的   n行   m列为闺房的地图，其中包括   :
. 代表路
* 代表墙
@ 代表CZ的起始位置
^ 代表闺房的出口
A-J 代表带锁的门,对应的钥匙分别为a-j
a-j 代表钥匙，对应的门分别为A-J

每组测试数据之间有一个空行。

Output

 针对每组测试数据，如果可以成功逃亡，请输出最少需要多少分钟才能离开，如果不能则输出   -1。

Sample Input

4 5 17
@A.B.
a*.*.
*..*^
c..b*

4 5 16
@A.B.
a*.*.
*..*^
c..b*

Sample Output

16
-1

 思路如下：

用进制转换的方法标记第三维，也就是钥匙的状态，

当前状态的钥匙存储状态，无法保证同一时刻正在进行的另一状态，

有无钥匙，所以说必须是三维数组，同时存储当前第三维所有 该钥匙位置的状态

代码如下：

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

const int INF = 1<<10;//将1左移十位
const int N = 22;
const int Size = 999999;
char map[N][N] ;
int vis[N][N][INF];//三维表示状态
struct node
{
    int x,y,z,ans ;
}q[Size];//结构体成员变量

int n,m,T;
int mv[4][2] = {{1,0},{0,-1},{-1,0},{0,1}};//定义一个移动数组

void BFS(int x ,int y)
{
    int s = 0 , e = 0  ;
    node f , t ;
    t.x = x ;
    t.y = y ;
    t.ans = 0 ;
    t.z = 0 ;
    q[e++] = t ;
    vis[t.x][t.y][t.z] = 1;
    while(s < e)
    {
        t = q[s++] ;
        if(map[t.x][t.y]=='^' && t.ans < T)//表示找到出口，直接输出步数，返回结果即可
        {
                printf("%d\n", t.ans);
                return ;
        }
        for(int i = 0;i < 4;i++)//否则循环4个方向进行搜索
        {
            f.x = t.x + mv[i][0];
            f.y = t.y + mv[i][1];
			f.z = t.z;
            if(f.x >= 0 && f.x < n && f.y >= 0 && f.y < m && vis[f.x][f.y][f.z]==0)
            {
                if(map[f.x][f.y]=='@' || map[f.x][f.y]=='.' || map[f.x][f.y]=='^')
                {
                    f.ans = t.ans  + 1;
                    q[e++] = f ;
                    vis[f.x][f.y][f.z] = 1 ;
                }
                else if('a' <= map[f.x][f.y] && map[f.x][f.y] <='j' )
                {
                    int sum = 0,kk,xx;
                    f.ans  = t.ans  + 1;
                    xx = f.z;
                    kk = map[f.x][f.y] - 'a' + 1;
                    for(int ll = 0;ll<kk;ll++)
                    {
                        sum = xx % 2;
                        xx /= 2;
                    }
                    if(sum==0)
                        f.z += pow(2,(map[f.x][f.y]-'a'));

                     vis[f.x][f.y][f.z] = 1 ;
                    q[e++] = f ;
                }
                else if('A' <= map[f.x][f.y] && map[f.x][f.y] <='J' )
                {
                    int sum = 0,kk,xx;
                    f.ans  = t.ans  + 1;
                    xx = f.z;
                    kk = map[f.x][f.y] - 'A' + 1;
                    for(int ll = 0;ll<kk;ll++)
                    {
                        sum = xx % 2;
                        xx /= 2;
                    }
                    if(sum==1)
                    {
                        f.ans  = t.ans  + 1;
                    q[e++] = f ;
                    vis[f.x][f.y][f.z] = 1 ;
                    }
                }
            }
        }
    }
    printf("-1\n");
}
int main()
{
    while(~scanf("%d%d%d",&n,&m,&T))
    {
            int x,y;
            memset(vis,0,sizeof(vis));//清空数组
            for(int i = 0 ; i < n ; i++)
            {
                scanf("%s%*c", map[i]);
            }
            for(int i = 0;i<n;i++)
            {
                 for(int j = 0;j < m;j++)
                {
                    if(map[i][j]=='@')
                    {
                        x = i;
                        y = j;
                        break;
                    }
                }
            }
       BFS(x,y);
    }
    return 0;
}
B - B
Time Limit:1000MS     Memory Limit:65536KB     64bit IO Format:%lld & %llu

 

Description

X，作为户外运动的忠实爱好者，总是不想呆在家里。现在，他想把死宅Y从家里拉出来。问从X的家到Y的家的最短时间是多少。

Input

多组输入。每组测试数据首先输入两个整数n，m(1<= n ,m<=15 )表示地图大小。接下来的n 行，每行n个字符。保证输入数据合法。

Output

若X可以到达Y的家，输出最少时间，否则输出 -1。

Sample Input

3 3
X#Y
***
#*#
3 3
X#Y
*#*
#*#

Sample Output

4
-1

Hint

思路如下：

分四个方向进行搜索，也可用bfs（广搜）或dfs（深搜）

代码如下：

   1.BFS

#include <stdio.h>
#include <string.h>

char Map[16][16];
int mv[16][16];

//mv[i][j] == 0 没有被访问
//mv[i][j] == 1 已经被访问

struct N
{
    int x,y,ans;
} q[300];

int jx[] = { 0,-1, 0, 1};
int jy[] = { 1, 0,-1, 0};

void bfs(int x,int y,int n,int m)
{
    int s = 0,e = 0;
    N t,f;

    t.x = x,t.y = y,t.ans = 0;

    q[e++] = t;

    mv[t.x][t.y] = 1;

    while(s < e)
    {
        t = q[s++];

//printf("x = %d,y = %d,ans = %d\n",t.x,t.y,t.ans);

        if(Map[t.x][t.y] == 'Y')
        {
            printf("%d\n",t.ans);
            return ;
        }

        for(int i = 0; i < 4; ++i)
        {
            f.x = t.x + jx[i];
            f.y = t.y + jy[i];

            if(0 <= f.x && f.x < n && 0 <= f.y && f.y < m && mv[f.x][f.y] == 0 && Map[f.x][f.y] != '#')
            {
                f.ans = t.ans+1;
                q[e++] = f;
                mv[f.x][f.y] = 1;
            }
        }
    }
    printf("-1\n");
    return ;
}

int main()
{
    int n,m,i,j;

    while(scanf("%d %d",&n,&m) != EOF)
    {
        memset(mv,0,sizeof(mv));

        for(i = 0; i < n; ++i)
        {
            scanf("%*c%s",Map[i]);
        }

        for(i = 0; i < n; ++i)
        {
            for(j = 0; j < m; ++j)
            {
                if(Map[i][j] == 'X')
                    break;
            }
            if(j != m)
                break;
        }

        bfs(i,j,n,m);
    }
    return 0;
}


  2.DFS

#include <stdio.h>
#include <string.h>

char Map[16][16];
int mv[16][16];

//mv[i][j] == 0 没有被访问
//mv[i][j] == 1 已经被访问

struct N
{
    int x,y,ans;
} q[300];

int jx[] = { 0,-1, 0, 1};
int jy[] = { 1, 0,-1, 0};

int Min;

void dfs(int x,int y,int n,int m,int ans)
{
    if(ans >= Min)
    {
        return ;
    }

    if(Map[x][y] == 'Y')
    {
        if(ans < Min)
        {
            Min = ans;
        }
        return ;
    }

    N f;

    for(int i = 0; i < 4; ++i)
    {
        f.x = x + jx[i];
        f.y = y + jy[i];

        if(0 <= f.x && f.x < n && 0 <= f.y && f.y < m && mv[f.x][f.y] == 0 && Map[f.x][f.y] != '#')
        {
            mv[f.x][f.y] = 1;
            dfs(f.x,f.y,n,m,ans+1);
            mv[f.x][f.y] = 0;
        }
    }
}

int main()
{
    int n,m,i,j;

    while(scanf("%d %d",&n,&m) != EOF)
    {
        memset(mv,0,sizeof(mv));

        for(i = 0; i < n; ++i)
        {
            scanf("%*c%s",Map[i]);
        }

        for(i = 0; i < n; ++i)
        {
            for(j = 0; j < m; ++j)
            {
                if(Map[i][j] == 'X')
                    break;
            }
            if(j != m)
                break;
        }

        Min = (1<<20);

        dfs(i,j,n,m,0);

        if(Min == (1<<20))
        {
            printf("-1\n");
        }
        else
        {
            printf("%d\n",Min);
        }

    }
    return 0;
}
C - C
Time Limit:1000MS     Memory Limit:65536KB     64bit IO Format:%lld & %llu

 

Description

You are given two pots, having the volume of A and B liters respectively. The following operations can be performed:

Input

 On the first and only line are the numbers A, B, and C. These are all integers in the range from 1 to 100 and C≤max(A,B).

Output

 The first line of the output must contain the length of the sequence of operations K.  If the desired result can’t be achieved, the first and only line of the file must contain the word ‘impossible’.

Sample Input

3 5 4

Sample Output

6

Hint

思路如下：

题意：给出两个容积分别为 a 和 b 的pot，按照以下三种操作方式，求出能否在一定步数后，使者两个pot的其中一个的水量为c。

      1.FILL(i)：将ipot倒满水。

      2.DROP(i)：将ipot倒空水。

      3.POUR(i,j)： 将ipot的水倒到jpot上，直至要么ipot为空，要么jpot为满。

 

思路：bfs求最短路径，与1426类似，只是每个节点的子节点数为6个而已。

代码如下：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;
int A, B, C;
int vis[105][105];
struct node
{
    int a, b, step;
};

void BFS()
{
    queue <node> q;
    int sa,sb;
    node f,t;
    f.a = 0; f.b = 0; f.step = 0;
    vis[f.a][f.b] = 1;
    q.push(f);
    while (!q.empty())
    {
        t = q.front();
        q.pop();
        if (t.a == C || t.b == C)
        {
            printf("%d\n",t.step);
            return ;
        }
        for (int i = 1; i <= 6; i++)
        {
            if (i == 1)
            {
                 sa = A;sb = t.b;
            }
            else if (i == 2)
            {
                 sa = t.a; sb = B;
            }
            else if (i == 3)
            {
                if (t.a + t.b > A)
                    {sb = t.a + t.b - A;sa = A;}
                else
                    {sb = 0; sa = t.a + t.b;}
            }
            else if (i == 4)
            {
                if (t.a + t.b > B)
                    {sa = t.a + t.b - B; sb = B;}
                else
                {
                    sa = 0; sb = t.a + t.b;
                }
            }
            else if (i == 5)
                {sa = 0; sb = t.b;}
            else
                {sa = t.a; sb = 0;}
            if (!vis[sa][sb])
            {
                vis[sa][sb] = 1;
                f.a = sa; f.b = sb;
                f.step = t.step + 1;
                q.push(f);
            }
        }
    }
    puts("impossible");
}

int main()
{
    while (scanf("%d%d%d", &A, &B, &C) != EOF)
    {
        memset(vis, 0, sizeof(vis));
        BFS();
    }
    return 0;
}


 



 

搜索算法--BFS和DFS
2302_80219536的博客
01-23 803
深度优先搜索，广度优先搜索
BFS与DFS模板总结
bitcarmanlee的博客
08-09 1842
剪枝”的意义在于让程序尽量不要执行到更深的递归结构中，而又不遗漏符合题意的解。当程序递归到底返回到原来执行的结点时，“状态”以及与“状态”相关的变量需要“重置”成第 1 次走到这个结点的状态，这个操作有个形象的名字，叫“回溯”，“回溯”有“恢复现场”的意思：意即“回到当时的场景，已经走过了一条路，尝试走下一条路”。状态通常是一个列表结构，因为一层一层递归下去，需要在列表的末尾追加，而返回到上一层递归结构，需要“状态重置”，因此要把列表的末尾的元素移除，符合这个性质的列表结构就是“栈”（只在一头操作）。...
DFS与BFS算法总结
一个重视算法和系统设计的实战派
12-23 846
【代码总结】DFS（深度优先搜索）、BFS（宽度优先搜索）算法总结
java DFS与BFS算法
qq_51194826的博客
04-22 3048
广度优先算法(BFS) BFS算法,它会对树或图进行"逐层"的遍历,也就是层序遍历，相较于DFS算法而言，BFS它不会直接到末尾，而是到下一层之前，会将节点的所有兄弟节点遍历完之后，再进入下一层。 ...
搜索算法-DFS BFS总结
wcy8733996wcy的博客
08-06 389
通过几天的刷题，对dfs和bfs算法有了更深一步的认识，下面来总结一下： 一、DFS 1.核心 一条路走到黑+回溯 2.分析 针对蓝桥杯历年真题中的剪格子来说： （1）dfs方法的参数：变化的坐标x、y，变化的格子数，变化的数之和。 （2）递归出口： 当和等于数组和的一半时，将全局变量min更新，回溯。 当和大于数组和的一半时，直接回溯。 （3）向当前格子的三个方向“探测”： 符合条件的标成已访问，避免进行下一次递归时，造成死循环。 当前递归完成后，再将其标成未访问，避免影响回溯后其他路径。 （4）递归完成
BFS与DFS总结
qq_41851496的博客
10-31 368
BFS与DFS总结 BFS与DFS基本操作与知识： 深度优先搜索是一个不断回溯的过程。 广度优先搜索是一层层遍历的过程。 BFS模板: BFS 使用队列，把每个还没有搜索到的点依次放入队列，然后再弹出队列的头部元素当做当前遍历点。BFS 总共有两个模板： 如果不需要确定当前遍历到了哪一层，BFS 模板如下： while queue 不空： cur = queue.pop() for 节点 in cur的所有相邻节点： if 该节点有效且未访问过：
Python - 深夜数据结构与算法之 BFS & DFS
BITDDD小栈
12-27 2617
Python BFS/DFS 简介与算法练习。
C++ BFS DFS 记忆化搜索
2302_79893174的博客
02-28 241
BFS：通过队列实现，适合用于寻找最短路径。DFS：通过递归实现，有三种遍历方式（前序、中序、后序）。记忆化搜索：通过存储已经计算过的结果来优化递归算法，避免重复计算，提高效率。
BFS与DFS的区别
2201_75442517的博客
04-13 1154
首先我们规定在这个无向图中每一条边权重均为一，(在BFS中我们会先创建一个队列，queue=[])我们先随机选择一个节点，B,我们将queue初始化为queue=[B],然后我们弹出队头元素，再次存入B的所有邻接点(A,C,D),queue=[A,C,D],出队头元素A，添加A的所有邻接点，(这里注意，因为B、C，之前访问过，所以我们不添加，假设我们添加那么我们就会循环往复，不断重复遍历)queue=[C,D],重复上述操作。对的吧，接下来我们从起点（0,0）出发，Go Go Go!
BFS&DFS总结
MOKE_SPACE
05-16 415
文章目录BFS、DFS 原理BFS 和 DFS 的实现BFSDFSBFS 和最短路径问题 刷题经常会碰到，在这里总结一下 BFS、DFS 原理 BFS： 广度优先搜索 DFS： 深度优先搜索 树的 BFS 相当于层次遍历这里主要说一下图的遍历，如下图： 从 A 开始进行 BFS 的过程： 首先和 A 相连的有 B、C，遍历序列为：A B C 然后再依次判断下一个点如 B、C ，相连的且不重复...
数据结构基础27: DFS和BFS算法总结
何哥的博客
02-16 8922
前言：图的遍历算法DFS和BFS是许多图算法的基础，所以有必要单独拎出来总结一下。DFS和BFS主要是运用于对于图和树的搜索，很多问题模型都是可以建模变成一个图或者树的，所以差不多不少问题都会涉及到这两个。比如求二叉树深度，可以是递归的方法，属于DFS（深度优先搜索）；另一种方法是按照层次遍历，属于BFS（广度优先搜索），想看代码的可以看《剑指Offer（三十八）：二叉树的深度》。再比如寻找一条路...
DFS BFS 图.zip_DFS BFS_bfs_bfs dfs_dfs_dfs bfs输出图
09-20
总结来说，DFS和BFS是图论中至关重要的搜索策略，它们各有优势，适用于不同的问题场景。通过理解这两种算法的工作原理和实现方式，我们可以有效地解决与图相关的复杂问题。结合这些文件，读者可以深入学习图的遍历...
搜索bfs,dfs
09-13
总结来说，宽度优先搜索（BFS）和深度优先搜索（DFS）是图论和树结构中不可或缺的搜索策略，它们在ACM竞赛和其他算法挑战中扮演着重要角色。理解并熟练掌握这两种搜索算法，将有助于你解决复杂的问题，并提升编程...
算法笔记--最短路径之dijkstra算法
flyljg的专栏
08-25 2773
１  最短路径算法 在日常生活中，我们如果需要常常往返A地区和B地区之间，我们最希望知道的可能是从A地区到B地区间的众多路径中，那一条路径的路途最短。最短路径问题是图论研究中的一个经典算法问题，旨在寻找图（由结点和路径组成的）中两结点之间的最短路径。 算法具体的形式包括： （１）确定起点的最短路径问题：即已知起始结点，求最短路径的问题。 （２）确定终点的最短路径问题：与确定起点的问题相反，该
学习笔记--最小生成树之prim算法
flyljg的专栏
08-23 2697
最小生成树之prim算法 边赋以权值的图称为网或带权图，带权图的生成树也是带权的，生成树T各边的权值总和称为该树的权。    最小生成树（MST）：权值最小的生成树。    生成树和最小生成树的应用：要连通n个城市需要n－1条边线路。可以把边上的权值解释为线路的造价。则最小生成树表示使其造价最小的生成树。    构造网的最小生成树必须解决下面两个问题：     1、尽可能选取权值小的边，
算法笔记---最短路路径之Floyd(弗洛伊德)算法
flyljg的专栏
08-25 1947
最短路路径之Floyd(弗洛伊德)算法 Floyd-Warshall算法（Floyd-Warshall algorithm）是解决任意两点间的最短路径的一种算法，可以正确处理有向图或负权的最短路径问题。 Floyd-Warshall算法的时间复杂度为O(N3)，空间复杂度为O(N2)。 [编辑]原理 Floyd-Warshall算法的原理是动态规划。 设Di,j,k为从i到j的只以(
学习笔记--最小生成树之kruskal算法
flyljg的专栏
08-23 1891
Kruskal算法   1.概览 Kruskal算法是一种用来寻找最小生成树的算法，由Joseph Kruskal在1956年发表。用来解决同样问题的还有Prim算法和Boruvka算法等。三种算法都是贪婪算法的应用。和Boruvka算法不同的地方是，Kruskal算法在图中存在相同权值的边时也有效。   2.算法简单描述 1).记Graph中有v个顶点，e个边 2).新建图Grap
算法笔记--树和二叉树
flyljg的专栏
08-23 1726
第六章  树和二叉树            本章主要讲授内容 　 1、树的定义和存储结构 　　 2、二叉树的定义、性质、存储结构 　　 3、二叉树的遍历、线索算法 　　 4、树和二叉树的转换 　　 5、哈夫曼树及其应用 ★★ 课时分配课时分配：1、2两个学时，3四个学时，4两个学时, 5两个学时,上机4个学时 ★★★ 重点、难点　：二叉树的遍历、线索算法、哈夫
栈和队列题目总结
flyljg的专栏
08-12 1313
传说中的数据结构    Time Limit: 1000MS    Memory limit: 65536K 题目描述       在大学里学习了一个学期了，大家大都对所学的专业有了基本的了解。许多同学也已经知道了到大二要开一门课叫做《数据结构》，那么今天给你们提前讲一下一个最简单的数据结构：栈。 栈的基本操作有3种：push，pop，top。 例如，给你一个数列：1 2 3
BFS DFS 操作复杂度
最新发布
06-21
根据引用内容，我们可以总结如下：###BFS（广度优先搜索）-**时间复杂度**：在最坏情况下，BFS需要遍历图中的所有节点和边。对于一个图，节点数为$|V|$，边数为$|E|$，则时间复杂度为$O(|V|+|E|)$（引用[2]和引用[3]...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值