搜索 （bfs，dfs） 总结

最新推荐文章于 2023-12-23 23:06:26 发布
最新推荐文章于 2023-12-23 23:06:26 发布
阅读量555 收藏
点赞数
分类专栏： 数据结构------搜索 总结
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/flyljg/article/details/38520349
版权
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;
}


 



 

flyljg
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
搜索bfs,dfs
09-13
总结来说，宽度优先搜索（BFS）和深度优先搜索（DFS）是图论和树结构中不可或缺的搜索策略，它们在ACM竞赛和其他算法挑战中扮演着重要角色。理解并熟练掌握这两种搜索算法，将有助于你解决复杂的问题，并提升编程...
数据结构图bfs，Dfs遍历算法
12-09
总结起来，数据结构中的图遍历算法，尤其是DFS和BFS，是理解和操作图形数据的基础。它们在实际编程问题中，如网络爬虫、社交网络分析、图形渲染等领域都有广泛应用。通过深入学习和实践这些算法，可以提升解决复杂...
BFS与DFS总结
qq_41851496的博客
10-31 273
BFS与DFS总结 BFS与DFS基本操作与知识： 深度优先搜索是一个不断回溯的过程。 广度优先搜索是一层层遍历的过程。 BFS模板: BFS 使用队列，把每个还没有搜索到的点依次放入队列，然后再弹出队列的头部元素当做当前遍历点。BFS 总共有两个模板： 如果不需要确定当前遍历到了哪一层，BFS 模板如下： while queue 不空： cur = queue.pop() for 节点 in cur的所有相邻节点： if 该节点有效且未访问过：
BFS与DFS模板总结
bitcarmanlee的博客
08-09 1181
剪枝”的意义在于让程序尽量不要执行到更深的递归结构中，而又不遗漏符合题意的解。当程序递归到底返回到原来执行的结点时，“状态”以及与“状态”相关的变量需要“重置”成第 1 次走到这个结点的状态，这个操作有个形象的名字，叫“回溯”，“回溯”有“恢复现场”的意思：意即“回到当时的场景，已经走过了一条路，尝试走下一条路”。状态通常是一个列表结构，因为一层一层递归下去，需要在列表的末尾追加，而返回到上一层递归结构，需要“状态重置”，因此要把列表的末尾的元素移除，符合这个性质的列表结构就是“栈”（只在一头操作）。...
DFS与BFS算法总结
最新发布
一个重视算法和系统设计的实战派
12-23 566
【代码总结】DFS（深度优先搜索）、BFS（宽度优先搜索）算法总结
dfs与bfs的简单总结及应用 | 详解
热门推荐
一只酷酷光儿的博客
03-02 5万+
写了三个小时的总结
搜索算法-DFS BFS总结
wcy8733996wcy的博客
08-06 323
通过几天的刷题，对dfs和bfs算法有了更深一步的认识，下面来总结一下： 一、DFS 1.核心 一条路走到黑+回溯 2.分析 针对蓝桥杯历年真题中的剪格子来说： （1）dfs方法的参数：变化的坐标x、y，变化的格子数，变化的数之和。 （2）递归出口： 当和等于数组和的一半时，将全局变量min更新，回溯。 当和大于数组和的一半时，直接回溯。 （3）向当前格子的三个方向“探测”： 符合条件的标成已访问，避免进行下一次递归时，造成死循环。 当前递归完成后，再将其标成未访问，避免影响回溯后其他路径。 （4）递归完成
DFS BFS 图.zip_DFS BFS_bfs_bfs dfs_dfs_dfs bfs输出图
09-20
总结来说，DFS和BFS是图论中至关重要的搜索策略，它们各有优势，适用于不同的问题场景。通过理解这两种算法的工作原理和实现方式，我们可以有效地解决与图相关的复杂问题。结合这些文件，读者可以深入学习图的遍历...
bfs-dfs.rar_BFS algoritm_BFS+c++
09-22
标题 "bfs-dfs.rar_BFS algoritm_BFS+c++" 指示了这个压缩包包含的是关于广度优先搜索（BFS）算法的实现，且是用C++编程语言编写的。描述 "bfs ,dfs algoritm in TC" 表明该算法在文本编辑器或编译器如Turbo C中进行...
PUZZLE15_dfs_C++求解15拼图问题_bfs_
10-02
总结来说，DFS、BFS和IDDFS都是有效的解决15拼图问题的方法，每种方法都有其优势和适用场景。在实际应用中，根据问题的特性选择合适的搜索算法是非常重要的。对于15拼图问题，IDDFS通常是最优的选择，因为它兼顾了...
算法笔记--最短路径之dijkstra算法
flyljg的专栏
08-25 2673
１  最短路径算法 在日常生活中，我们如果需要常常往返A地区和B地区之间，我们最希望知道的可能是从A地区到B地区间的众多路径中，那一条路径的路途最短。最短路径问题是图论研究中的一个经典算法问题，旨在寻找图（由结点和路径组成的）中两结点之间的最短路径。 算法具体的形式包括： （１）确定起点的最短路径问题：即已知起始结点，求最短路径的问题。 （２）确定终点的最短路径问题：与确定起点的问题相反，该
学习笔记--最小生成树之prim算法
flyljg的专栏
08-23 2379
最小生成树之prim算法 边赋以权值的图称为网或带权图，带权图的生成树也是带权的，生成树T各边的权值总和称为该树的权。    最小生成树（MST）：权值最小的生成树。    生成树和最小生成树的应用：要连通n个城市需要n－1条边线路。可以把边上的权值解释为线路的造价。则最小生成树表示使其造价最小的生成树。    构造网的最小生成树必须解决下面两个问题：     1、尽可能选取权值小的边，
算法笔记---最短路路径之Floyd(弗洛伊德)算法
flyljg的专栏
08-25 1858
最短路路径之Floyd(弗洛伊德)算法 Floyd-Warshall算法（Floyd-Warshall algorithm）是解决任意两点间的最短路径的一种算法，可以正确处理有向图或负权的最短路径问题。 Floyd-Warshall算法的时间复杂度为O(N3)，空间复杂度为O(N2)。 [编辑]原理 Floyd-Warshall算法的原理是动态规划。 设Di,j,k为从i到j的只以(
学习笔记--最小生成树之kruskal算法
flyljg的专栏
08-23 1789
Kruskal算法   1.概览 Kruskal算法是一种用来寻找最小生成树的算法，由Joseph Kruskal在1956年发表。用来解决同样问题的还有Prim算法和Boruvka算法等。三种算法都是贪婪算法的应用。和Boruvka算法不同的地方是，Kruskal算法在图中存在相同权值的边时也有效。   2.算法简单描述 1).记Graph中有v个顶点，e个边 2).新建图Grap
算法笔记--树和二叉树
flyljg的专栏
08-23 1663
第六章  树和二叉树            本章主要讲授内容 　 1、树的定义和存储结构 　　 2、二叉树的定义、性质、存储结构 　　 3、二叉树的遍历、线索算法 　　 4、树和二叉树的转换 　　 5、哈夫曼树及其应用 ★★ 课时分配课时分配：1、2两个学时，3四个学时，4两个学时, 5两个学时,上机4个学时 ★★★ 重点、难点　：二叉树的遍历、线索算法、哈夫
栈和队列题目总结
flyljg的专栏
08-12 1205
传说中的数据结构    Time Limit: 1000MS    Memory limit: 65536K 题目描述       在大学里学习了一个学期了，大家大都对所学的专业有了基本的了解。许多同学也已经知道了到大二要开一门课叫做《数据结构》，那么今天给你们提前讲一下一个最简单的数据结构：栈。 栈的基本操作有3种：push，pop，top。 例如，给你一个数列：1 2 3
最大流（刚开始接触的总结）
flyljg的专栏
08-18 951
刚开始接触最大流问题，也是一头雾水，看了一上午的
算法笔记---最短路径之bellman-ford算法
flyljg的专栏
08-25 940
最短路径之bellman-ford算法 Dijkstra算法是处理单源最短路径的有效算法，但它局限于边的权值非负的情况，若图中出现权值为负的边，Dijkstra算法就会失效，求出的最短路径就可能是错的。这时候，就需要使用其他的算法来求解最短路径，Bellman-Ford算法就是其中最常用的一个。该算法由美国数学家理查德•贝尔曼（Richard Bellman, 动态规划的提出者）和小莱斯
算法笔记--最短路径之SPFA算法
flyljg的专栏
08-25 919
第四种解法：SPFA算法 这种算法可以说是Bellman_Ford算法的优化，就是在Bellman_Ford算法的基础上加上队列实现， SPFA(Shortest Path Faster Algorithm) 算法大致流程是用一个队列来进行维护。 初始时将源加入队列。 每次从队列中取出一个元素，并对所有与他相邻的点进行松弛，若某个相邻的点松弛成功，则将其入队。直到队列为空
BFS和DFS C++算法
09-04
总结起来，BFS和DFS是常用的图搜索算法，它们在搜索策略和复杂度上有不同。BFS逐层扩展搜索，适用于最短路径和最小生成树等问题。DFS深度优先搜索，适用于寻找所有可能解的问题。具体选择哪种算法取决于问题的特点和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值