深度和广度搜索

最新推荐文章于 2024-07-08 21:32:52 发布
最新推荐文章于 2024-07-08 21:32:52 发布
阅读量530 收藏
点赞数
分类专栏： 算法 文章标签： 深度优先搜索 广度优先搜索
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/csu54zzg/article/details/44284277
版权

深度和广度搜索

1.     全排列

输入n，输出1-n所有的非重复全排列


import java.util.Scanner;

 

public class Main {

    public static void main(String[] args) {

       Scanner in = new Scanner(System.in);

       n = in.nextInt();

       queue = new int[n];

       mark = new int[n];

       dfs(0);

    }

   

    private static int n;

    private static int[] queue;

    private static int[] mark;

    public static void dfs(int step) {

       if(step == n) {

           for(int i = 0;i<n;i++) {

              System.out.print(queue[i]);

           }

           System.out.println(); 

           return;

       }

       for(int i = 0;i<n;i++) {

           if(mark[i] == 0) {

              mark[i] = 1;

              queue[step] = i+1;

              dfs(step+1);

              mark[i] = 0;

           }

       }  

    }

}

 

2.     在□□□+□□□=□□□中填入1-9，输出可能的填法


import java.util.Scanner;

 

public class Main {

    public static void main(String[] args) {

       Scanner in = new Scanner(System.in);

       queue = new int[9];

       mark = new int[9];

       dfs(0);

    }

 

    private static int[] queue;

    private static int[] mark;

    public static void dfs(int step) {

       if(step == 9) {

           if(queue[0]*100+queue[1]*10+queue[2]+

                  queue[3]*100+queue[4]*10+queue[5]==

                  queue[6]*100+queue[7]*10+queue[8]) {

              for(int i = 0;i<9;i++) {

                  System.out.print(queue[i]);

                  if(i == 2) {

                     System.out.print("+");

                  }

                  if(i ==5) {

                     System.out.print("=");

                  }

              }

              System.out.println();

           }

           return;

       }

       for(int i = 0;i<9;i++) {

           if(mark[i] == 0) {

              mark[i] = 1;

              queue[step] = i+1;

              dfs(step+1);

              mark[i] = 0;

           }

       }  

    }

}

3.     玩迷宫

迷宫由n行和m列的单元格组成，每个单元格要么是空地，要么是障碍物。找到一条从起点到终点的最短路径。

用一个二源数组来存储这个迷宫，起点（0,0）终点（p,q）。

输入 n m和迷宫，1表示障碍物


深度Depth-first search

import java.util.Scanner;

 

public class Main {

    public static void main(String[] args) {

       Scanner in = new Scanner(System.in);

       n = in.nextInt();

       m = in.nextInt();

       maze = new int[n][m];

       mark = new boolean[n][m];

       currentPath = new int[n*m][2];

       minPath = new int[n*m][2];

       location = new int[2][2];

       for(int i = 0;i<n;i++)

           for(int j = 0;j<m;j++) {

              maze[i][j] = in.nextInt();

           }

       location[0][0] = in.nextInt(); //当前点

       location[0][1] = in.nextInt();

       location[1][0] = in.nextInt(); //终点

       location[1][1] = in.nextInt();

      

       mark[location[0][0]][location[0][1]] = true;

      

       dfs(location[0][0],location[0][1]);

       if(minPathLen > 0) {

           System.out.println(minPathLen);

           for(int i = 0;i<=minPathLen;i++) {

              System.out.print("("+minPath[i][0]+","+minPath[i][1]+") ");

           }

       } else {

           System.out.println("Sorry");

       }

      

 

    }

   

    private static int n;  //行

    private static int m;  //列

    private static int[][] maze; //迷宫

    private static boolean[][] mark; //标记是否被访问

    private static int[][] location;//起点和终点

    private static int[][] currentPath;

    private static int[][] minPath;

    private static int minPathLen = Integer.MAX_VALUE;

    private static int currentPathLen = 0;

    private static int[][] dirMove= {{0,1},

       {1,0},

       {0,-1},

       {-1,0}};

   

    public static void dfs(int xx, int yy) {

       //return

       if(xx == location[1][0] &&

              yy == location[1][1]) {

           if(minPathLen > currentPathLen) {

              minPathLen = currentPathLen;

              for(int i = 0;i<=minPathLen;i++) {

                  minPath[i][0] = currentPath[i][0];

                  minPath[i][1] = currentPath[i][1];

              }

           }

           currentPathLen = 0;

           return;

       }

       for(int ii = 0;ii<4;ii++) {

           int x = xx + dirMove[ii][0];

           int y = yy + dirMove[ii][1];   

           //越界

           if(x<0 || y<0 || x>=n || y>=m) {

              continue;

           }

           //障碍物

           if(maze[x][y] == 1) {

              continue;

           }

          

           //

           if(mark[x][y] == true)

              continue;

           mark[x][y] = true;

           currentPathLen++;

           currentPath[currentPathLen][0] = x;

           currentPath[currentPathLen][1] = y;   

           dfs(x,y);

           mark[x][y] = false;

       }

    }

 

}

广度Board-first search

import java.util.Scanner;

 

public class Main {

    public static void main(String[] args) {

       Scanner in = new Scanner(System.in);

       n = in.nextInt();

       m = in.nextInt();

       maze = new int[n][m];

       location = new int[2][2];

       for(int i = 0;i<n;i++)

           for(int j = 0;j<m;j++) {

              maze[i][j] = in.nextInt();

           }

       location[0][0] = in.nextInt(); //当前点

       location[0][1] = in.nextInt();

       location[1][0] = in.nextInt(); //终点

       location[1][1] = in.nextInt();

       queue = new int[n*m][4]; //将遍历过得点存储，xy和父节点的下标和步数

       mark = new boolean[n][m];

       queue[0][0] = location[0][0];

       queue[0][1] = location[0][1];

       queue[0][2] = 0;

       queue[0][3] = 0;

       int x=location[0][0],y=location[0][1];

       mark[x][y] = true;

       boolean flag = false;

       tail++;

             

       while(head < tail) {

           int xx = queue[head][0],yy = queue[head][1];

           for(int i = 0;i<4;i++) {

              x = xx + dirMove[i][0];

              y = yy + dirMove[i][1];

              if(x <0 || y<0 || x>= n || y>= m)

                  continue;

              if(mark[x][y] == true)

                  continue;

              if(maze[x][y] == 1)

                  continue;

              mark[x][y] = true;

              queue[tail][0] = x;

              queue[tail][1] = y;

              queue[tail][2] = head;   //父节点

              queue[tail][3] = queue[head][3]+1; //父节点步数+1

              tail++;

              if(x == location[1][0] && y == location[1][1]) {

                  flag = true;

                  break;

              }

           }

           if(flag)

              break;

           head++;

       }

       System.out.println(queue[head][3]+1);

 

    }

   

    private static int n;  //行

    private static int m;  //列

    private static int[][] maze; //迷宫

    private static int[][] location;//起点和终点

    private static int queue[][];  //队列

    private static int head = 0;

    private static int tail = 0;

    private static int len = 0;//遍历的层数

    private static boolean mark[][];//标记是否被遍历

    private static int[][] dirMove= {{0,1},

       {1,0},

       {0,-1},

       {-1,0}};

 

 

}

4.     宝岛探险

宝岛由主岛和附属岛屿组成，海洋和陆地。其航拍图由二维数组矩阵组成。

问题1：统计其面积大小。广度搜索和深度搜索。

问题2：独立岛屿的个数。从某点开始给所有的点遍历，每个点及其连接点深度搜索染色，多少种颜色，多少个岛屿。

种子填充法：图像分割、物体识别。

5． 水管工游戏

 

csu54zzg
关注
专栏目录
matlab利用深度和广度搜索解决八数码问题
08-13
本文将深入探讨如何使用MATLAB语言结合深度优先搜索（DFS）和广度优先搜索（BFS）策略来解决这个问题。MATLAB作为一种强大的数值计算和编程环境，非常适合进行这种逻辑和算法的实现。 首先，我们来理解八数码问题的...
python深度优先搜索和广度优先搜索
09-20
总结，Python中的深度优先搜索和广度优先搜索是图遍历的重要工具，它们各有优势，适用于不同的问题场景。DFS适合于探索深度优先的解，而BFS则更适合寻找最短路径。了解和熟练掌握这两种算法对于解决实际的编程问题...
技术的广度与深度
guotufu的博客
06-26 6442
一般来说，我们都希望自己的技术既有广度又有深度，但事实上，鱼与熊掌不可兼得，我们人的一生其实很短暂，在这有限的时间和精力里，我们不可能掌握所有的技术，而且技术的更新速度很快，就如同浩瀚的大海一样。那么我们应该如何掌握好时间效率？如何才能不浪费生命呢？这个除了三观要正之外，还得需要有一个正确的学习方式，端正的态度。下面具体来说说要如何提高自己的广度和深度。一、广度为辅，深度为主。既然人生有限，我们不...
深度遍历和广度遍历
午夜阳光
03-09 2620
一、树的深度和广度遍历        树的深度搜索与树的前序遍历同理，根节点->左孩子->右孩子；树的广度搜索与树的层次遍历同理，一层一层遍历内容。深度搜索采用stack的适配器，先进后出原则；而广度搜索采用的queue适配器，先进先出原则，二者正好满足搜索需求。 源码如下： #include #include #include #include using namespace st
万能的搜索——深度搜索和广度搜索
明里灰的博客
12-04 6788
搜索分为深度优先搜索（dfs）和广度优先搜索（bfs）先学习深度优先搜索。深度搜素是往深度方向进行搜索的，先选一条路走到底，再选另一条路，用于二维数组和二维字符数组。【题目描述】有一天，小哈一个人去玩迷宫。但是方向感很不好的小哈很快就迷路了。小哼得知后便要去解救无助的小哈。小哼当然是有备而来，已经弄清楚了迷宫的地图，现在小哼要以最快的速度去解救小哈。问题就此开始了…… 迷宫由n行m列的单元格组成（n和m都小于等于50），每个单元格要么是空地（用0表示），要么是障碍物（用1表示）。你的任务是帮助小哼找到一条从
深度优先搜索和广度优先搜索 使用场景
最新发布
wt_better的博客
07-08 317
深度优先搜索（Depth-First Search, DFS）和广度优先搜索（Breadth-First Search, BFS）是图和树结构中常用的遍历算法。两者适用于不同的场景。
leetcode深度优先搜索和广度优先搜索总结 Python
BIT_Legend的博客
01-03 1511
访问完右分支后，退回到最初根节点的上一级节点，再访问右分支。迭代法的思路其实是以层作为粒度，弹出一层的所有节点，然后放进去下面一层的所有节点，这里需要在注意的是在 que 中我们是无法区分两个节点是否来自于同一层的，所以在编程时，需要实现获取一层的长度。递归法就是函数在函数实现中调用函数本身，但函数实现中还需要增加调用终止条件，在函数实现中可以先假定函数已经实现，所以在考虑一个根节点和两个子节点时，可以直接调用函数本身实现两个子节点的遍历，函数实现中仅仅考虑根节点的遍历和终止条件即可，编程思路一目了然。
深度优先搜索与广度优先搜索，你知道它们的区别吗？
万猫学社
04-25 2710
深度优先搜索（DFS，Depth-First Search）是算法中的一种重要的搜索策略。它的核心思想是“深入探索，直至无路可走，然后再回溯”。这种策略在许多问题中都有着广泛的应用，例如图的遍历、路径查找、解决迷宫问题等等。让我们通过一个生活中的例子来理解深度优先搜索。假设你正在玩一个迷宫游戏，你需要从迷宫的入口找到出口。你可以选择往前走，直到遇到死胡同，然后再回头，选择另外一个方向继续前进，直到找到出口。这个过程，就是深度优先搜索的一个形象展现。
广度优先搜索和深度优先搜索
liulanba的博客
03-09 1568
以邻接矩阵表示时，查找每个顶点的邻接点所需的时间为0(V)，故总的时间复杂度为0（V²).以邻接表表示时，查找所有顶点的邻接点所需的时间为O(E)，访问顶点所需的时间为0（V)），此时，总的时间复杂度为O(V+|E|)。采用邻接表存储方式时，每个顶点均需搜索一次（或入队一次)，故时间复杂度为0(V)，在搜索任一顶点的邻接点时，每条边至少访问一次，故时间复杂度为 0(E)，算法总的时间复杂度为0(V+E)。注意：图的邻接矩阵表示是唯一的，但对于邻接表来说，若边的输入次序不同，生成的邻接表也不同。
深度优先和广度优先
学海无涯,我用JAVA
12-30 1370
搜索方式不同。深度优先搜索算法不全部保留结点，扩展完的结点从数据库中弹出删去；广度优先搜索算法需存储产生的所有结点。运行速度不同。深度优先搜索算法有回溯操作，运行速度慢；广度优先搜索算法无回溯操作，运行速度快。占用空间不同。深度优先搜索算法占用空间少；广度优先搜索算法占用空间大。作用不同。虽然都可以完成树形结构的遍历，但是深度优先一般用于需要先处理最深层级逻辑，广度优先一般用于层层节点展开的处理逻辑；深度优先 用栈;广度优先 用队列;
【C 数据结构-图】3. 深度优先搜索、广度优先搜索
普罗米修斯的博客
04-29 1631
文章目录【 1. DFS 深度优先搜索 】1.1 基本原理1.2 C 实现【 2. BFS 广度优先搜索 】2.1 基本原理2.2 C 实现 对存储的图中的顶点进行遍历搜索，常用的遍历方式有两种：深度优先搜索和广度优先搜索。 【 1. DFS 深度优先搜索 】 1.1 基本原理 深度优先搜索的过程 类似于树的先序遍历，首先从例子中体会深度优先搜索。例如下图是一个无向图，采用深度优先算法遍历这个图的过程为： 首先任意找一个未被遍历过的顶点，例如从 V1 开始，由于 V1 率先访问过了，所以，需要标记
dp.rar_广度优先_深度优先_深度搜索 广度搜索
09-24
在计算机科学领域，图遍历是解决许多问题的关键技术之一，而深度优先搜索（DFS，Depth First Search）和广度优先搜索（BFS，Breadth First Search）就是两种常用的图遍历算法。这两个算法主要应用于有向图或无向图的...
Java编程实现基于图的深度优先搜索和广度优先搜索完整代码
08-28
Java编程实现基于图的深度优先搜索和广度优先搜索完整代码 本文主要讲解了Java编程实现基于图的深度优先搜索和广度优先搜索完整代码，包括深度优先搜索（DFS）和广度优先搜索（BFS）的概念、算法实现和应用场景。 ...
字符串之排序
csu54zzg的专栏
03-22 5870
Java中String类来表示字符串，主要特性： 字符：String由一系列字符组成，字符的类型char，7位ascii，16位Unicode编码。 不可变性：String对象不可变。 索引：String类中的charAt()。 长度：String类中的length()。 子字符串：subString()。 字符串的连接：StringBuilder，toString，+运算符。 字符
排序
csu54zzg的专栏
08-25 976
初级排序：选择、插入、希尔 考虑：比较和交换的数量，访问数组的次数，内存开销【原地和副本】和运行时间 NXN的表格，对角线数据   常数：1，普通语句，2个数相加 对数：logN，二分策略，二分查找 线性：N，循环，找出最大的元素 线性对数：NlogN，分治，归并排序 平方：N2，双层循环，检查所有的元素对、 立方：N3，三层循环，检查所有的三元组 指数级别：2N，穷举查找，检
Posts Tagged 【hashMap && Double Linked List】LRU Cache
csu54zzg的专栏
05-06 809
LRU Cache  Total Accepted: 37708 Total Submissions: 253143My Submissions Question  Solution  Design and implement a data structure for Least Recently Used (LRU) cache. It should supp
图
csu54zzg的专栏
08-25 799
无向图 图：由一组顶点和一组能够将两个顶点相连的边组成。边edge  顶点vertex 自环、平行边 树：一幅无环连通图。 森林：互不相连的树组成的结合。 图的表示方法： 邻接矩阵：N×N的布尔矩阵。空间大、不允许平行边的存在 边的数组：使用一个Eage类，含有两个int实例变量。不易检查图中的所有边。 邻接表数组：以顶点为索引的链表数组。将每个顶点的所有相邻顶点都保存在该顶点对应
"探索社交网络：深度和广度搜索三度好友关系
深度优先搜索和广度优先搜索是常用的图搜索算法，可以应用于社交网络中查找三度好友关系这样的场景。在社交网络中，我们通常通过用户之间的连接关系来推荐可能认识的人。而要找出一个用户的所有三度好友关系，我们...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值