acwing DFS BFS学习笔记

于 2022-12-23 18:01:01 发布
阅读量201 收藏
点赞数
文章标签： java 深度优先 算法 广度优先
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_55670428/article/details/128422495
版权

DFS（回溯+剪枝）

DFS注意顺序

一条路走到黑即选择一个方法一直走到尾部，到尾部之后返回上一个节点判断另一个方案直到本节点可以访问的节点区别访问完毕

桉树型结构来理解的话类似前序遍历

树的前序遍历是指对于树中的每个节点，先访问该节点，然后递归地访问该节点的左子树，再递归地访问该节点的右子树。树的中序遍历是指对于树中的每个节点，先递归地访问该节点的左子树，再访问该节点，最后递归地访问该节点的右子树。树的后序遍历是指对于树中的每个节点，先递归地访问该节点的左子树，再递归地访问该节点的右子树，最后访问该节点。简单来说，前序遍历是根左右，中序遍历是左根右，后序遍历是左右根。这三种遍历的顺序不同，因此它们可以被用来完成不同的任务。例如，在二叉搜索树中，中序遍历可以按照顺序访问树中的所有节点，因此可以用来排序。后序遍历则可以用来计算树中节点的后继和前驱。

经典案例：

给定一个整数 nn，将数字 1∼n1∼n 排成一排，将会有很多种排列方法。

现在，请你按照字典序将所有的排列方法输出。

输入格式

共一行，包含一个整数 nn。

输出格式

按字典序输出所有排列方案，每个方案占一行。

数据范围

1≤n≤71≤n≤7

输入样例：

3

输出样例：

1 2 3
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1
package ACWing.SearchAndGraphTheory.DFS;
//842. 排列数字
​
import java.util.ArrayList;
import java.util.Scanner;
​
/**
 * @author :chenjie
 * @date :Created 2022/12/15 18:42
 */
public class StaggeredNumerals {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        ArrayList<Integer> list=new ArrayList<>();
        boolean[]arr=new boolean[n+1];
        dfs(list,n,arr);
​
    }
    public static void dfs(ArrayList<Integer> list,int n,boolean[]arr){
        if(list.size()==n){
            for (Integer integer : list) {
                System.out.print(integer+" ");
​
            }System.out.println();
            return;
        }
        for (int i = 1; i <= n; i++) {
            if (!arr[i]){
                list.add(i);
                arr[i]=true;
                dfs(list,n,arr);
                //恢复现场回归到上次的状态
                list.remove(list.size()-1);
                arr[i]=false;
            }
        }
​
    }
}

经典8皇后问题

package ACWing.SearchAndGraphTheory.DFS;
//843. n-皇后问题
import java.util.Scanner;
​
/**
 * @author :chenjie
 * @date :Created 2022/12/15 22:13
 */
public class NQueensRroblem {
    static String[][]arr=new String[20][20];//用截距来判断b=y+x所以有可能是20所以用20
    static boolean[]col=new boolean[20];
    static boolean[]dg=new boolean[20];
    static boolean[]udg=new boolean[20];
    static boolean[]row=new boolean[20];
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                arr[i][j]=".";
            }
        }
        //dfs(0,n);
        dfs2(0,0,0,n);
    }
    public static void dfs(int u,int n){
        if(u==n){
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    System.out.print(arr[i][j]);
                }
                System.out.println();
            }
            System.out.println();
            return;
        }
        for (int i = 0; i < n; i++) {
            if(!col[i]&&!dg[u+i]&&!udg[n-u+i]){//精华所在用截距来判断对角线
                arr[u][i]="Q";
                col[i]=dg[u+i]=udg[n-u+i]=true;
                dfs(u+1,n);
                col[i]=dg[u+i]=udg[n-u+i]=false;
                arr[u][i]=".";
            }
        }
    }
    //解法二与上解法的差别在于解法二通过递归遍历了整个节点去判断是否要放皇后解法一是通过循环去判断一整行如何递归到下一行
    public static void dfs2(int x,int y,int s,int n){
        //设置边界条件
        if(y==n){
            y=0;
            x++;
        }
        if(x==n){
            if(s==n){
                for (int i = 0; i < n; i++) {
                    for (int j = 0; j < n; j++) {
                        System.out.print(arr[i][j]);
                    }
                    System.out.println();
                }
                System.out.println();
            }return;
        }
​
        //不放皇后
        dfs2(x,y+1,s,n);
​
        //放皇后
        if(!row[x]&&!col[y]&&!dg[x+y]&&!udg[x-y+n]){//条件允许的情况下放皇后
            arr[x][y]="Q";
            row[x]=col[y]=dg[x+y]=udg[x-y+n]=true;
            dfs2(x,y+1,s+1,n);
            row[x]=col[y]=dg[x+y]=udg[x-y+n]=false;
            arr[x][y]=".";
        }
    }
}
​

大体的思路一致没有具体的模板

弹出（边界）条件

进入符合条件的递归

恢复现场

刷题总结：

先判断暴力搜索的情况是否为有顺序的接下去搜索还是全排列，因为时间复杂度不够确定所以尽可能剪枝来缩小查询次数

如果是不按顺序搜索的话一般情况下便是这种模板（全排列）

例题：//184. 虫食算 InsectFeedingCalculation

private  static boolean  dfs(int u) {
    if(u==n){
        return true;
    }
    for (int i = 0; i < n; i++) {
        if(!st[i]){
            path[qu[u]]=i;
            st[i]=true;
            if(check()&&dfs(u+1)){
                return true;
            }
            path[qu[u]]=-1;
            st[i]=false;
        }
    }
​
    return false;
}

如果是按顺序搜索的话一般便是这种模板（内含有一个遍历的过程必须按照顺序进行遍历组合）即按顺序进行选择来遍历所有的选择情况每种情况之后都必须要恢复现场

例题//187. 导弹防御系统 MissileDefenseSystem

public static void dfs(int[]arr,int su,int sd,int k,int n){
    弹出条件
    第一种一种情况
    第二种情况
        .
        .
        .
        
}

dfs求组合数类型：

先对要组合的数排序再进行dfs而且必须保证值的不降序性

洛谷例题：

package luogu.dfs;
//P1036 [NOIP2002 普及组] 选数
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
​
/**
 * @author :chenjie
 * @date :Created 2022/12/22 21:38
 */
public class Selectron {
    static boolean[]st=new boolean[30];
​
    static int n;
    static int m;
    static int sum=0;
    static List<Integer> set=new ArrayList<>();
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        n=sc.nextInt();
        m=sc.nextInt();
        int[]arr=new int[n];
        for (int i = 0; i < n; i++) {
            arr[i]=sc.nextInt();
        }
        Arrays.sort(arr);
        dfs(0,0,arr);
        int num=0;
        for (Integer integer : set) {
            if(sushu(integer)){
                num++;
            }
        }
        System.out.println(num);
    }
    public static void dfs(int u,int a,int[]arr){//a和u其实可以合并
        if(u==m){
            set.add(sum);
            return;
        }
        for (int i = a; i < n; i++) {
            if(!st[i]){
                sum=sum+arr[i];
                st[i]=true;
                dfs(u+1,i+1,arr);
                sum=sum-arr[i];
                st[i]=false;
            }
        }
    }
    public static boolean sushu(int a){
        for (int i = 2; i < Math.sqrt(a); i++) {
            if(a%i==0){
                return false;
            }
        }
        return true;
    }
}

BFS

按数来理解的话就是依次遍历整层，一层一层遍历，适用与查找最短路径，最短步数等等根据情况使用

将所有一步可以走到的节点全部存到队列中，因为队列的先进先出特性所以必定可以保证先遍历完路径为1的节点才能去遍历2的节点所以保证了到某个点的距离最短

经典迷宫问题

给定一个 n×mn×m 的二维整数数组，用来表示一个迷宫，数组中只包含 00 或 11，其中 00 表示可以走的路，11 表示不可通过的墙壁。

最初，有一个人位于左上角 (1,1)(1,1) 处，已知该人每次可以向上、下、左、右任意一个方向移动一个位置。

请问，该人从左上角移动至右下角 (n,m)(n,m) 处，至少需要移动多少次。

数据保证 (1,1)(1,1) 处和 (n,m)(n,m) 处的数字为 00，且一定至少存在一条通路。

输入格式

第一行包含两个整数 nn 和 mm。

接下来 nn 行，每行包含 mm 个整数（00 或 11），表示完整的二维数组迷宫。

输出格式

输出一个整数，表示从左上角移动至右下角的最少移动次数。

数据范围

1≤n,m≤1001≤n,m≤100

输入样例：

5 5
0 1 0 0 0
0 1 0 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0

输出样例：

8

思路将这一层符合条件的坐标放入队列中，在进入下一层时从队列中取出上一层的坐标进行上下左右的判断以此类推最后遍历到最后一层无法遍历为止

便可以求出这个点到每个点的最短路径（权重相等时是最短路径）

package ACWing.SearchAndGraphTheory.BFS;
//844 走迷宫

import java.util.ArrayDeque;
import java.util.Queue;
import java.util.Scanner;

/**
 * @author :chenjie
 * @date :Created 2022/12/15 18:42
 */
public class WalkTGHEMaze {
    static class Pall{
        int x;
        int y;

        public Pall(int x, int y) {
            this.x = x;
            this.y = y;
        }

        @Override
        public String toString() {
            return "Pall{" +
                    "x=" + x +
                    ", y=" + y +
                    '}';
        }
    }
    static Pall[][]palls=new Pall[110][110];//记录路径
    static Queue<Pall> queue=new ArrayDeque<>();
    static int[][]d=new int[110][110];
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int m=sc.nextInt();
        int[][]arr=new int[n][m];
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < m; j++) {
                arr[i][j]=sc.nextInt();
            }
        }
        //初始化距离-1为未被访问过
        for (int i = 0; i <n; i++) {
            for (int j = 0; j < m; j++) {
                d[i][j]=-1;
            }
        }
        System.out.println(bfs(n, m, arr));
        int x=n-1,y=m-1;
        while (x!=0||y!=0){
            System.out.println(x+" "+y);
            x=palls[x][y].x;
            y=palls[x][y].y;
        }

    }
    public static int bfs(int n,int m,int[][]arr){
        queue.add(new Pall(0,0));
        palls[0][0]=new Pall(0,0);
        d[0][0]=0;
        //扩展元素的坐标上下左右
        int[]dx={-1,0,1,0};
        int[]dy={0,1,0,-1};
        while (queue.size()>0){
            Pall t=queue.poll();
            for (int i = 0; i < 4; i++) {
                int x=t.x+dx[i],y=t.y+dy[i];
                if(x>=0&&x<n&&y>=0&&y<m&&d[x][y]==-1&&arr[x][y]==0){
                    d[x][y]=d[t.x][t.y]+1;
                    palls[x][y]=t;
                    queue.add(new Pall(x,y));
                    
                }
            }
        }
        return d[n-1][m-1];
    }
}

package ACWing.SearchAndGraphTheory.BFS;
//845. 八数码

import java.util.*;

/**
 * @author :chenjie
 * @date :Created 2022/12/17 13:01
 */

/**
 * 本题的总体思路：
 * bfs：将所有一步可以走到的节点全部存到队列中，因为队列的先进先出特性所以必定可以保证先遍历完路径为1的节点才能去遍历2的节点所以保证了到某个点的距离最短
 * 而本题难点在于如何存储节点的状态和存储节点对应的距离
 * 存储节点的状态：题目也有提示1 2 3 x 4 6 7 5 8这样输入便是可以将二维数组压成一维。在进行做题
 * 存储节点对应的距离：刚好就对应hashmap类
 */
public class TheEightDigits {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        String s="";
        for (int i = 0; i < 9; i++) {
            s+=sc.next();
        }
        System.out.println(s);
        System.out.println(bfs(s));
    }
    public static int bfs(String t){
        Queue<String> queue=new ArrayDeque<>();//记录状态
        queue.add(t);
        Map<String ,Integer> map=new HashMap<>();//记录对应的步数
        map.put(t,0);
        int[]dx={1,-1,0,0};
        int[]dy={0,0,1,-1};
        while (!queue.isEmpty()){
            String s = queue.remove();
            if("12345678x".equals(s)){
                return map.get(s);
            }
            int n=s.indexOf('x');
            int x=n/3;
            int y=n%3;
            for (int i = 0; i < 4; i++) {
                int a=x+dx[i],b=y+dy[i];//遍历上下左右
                if(a>=0&&b>=0&&a<3&&b<3){
                    int l=map.get(s);
                    String str=swap(s,n,a*3+b);//必须用对象来接副本不然直接用s=的话会出现意外
                    if(map.containsKey(str)){//如果已经走过来便不在走
                        continue;
                    }
                    map.put(str,l+1);
                    queue.add(str);
                }
            }
        }
        return -1;

    }

    /**
     * setCharAt是精髓所在原本我只能转成char在操作现在可以在字符串上进行修改
     * 交换字符串中的俩个字符
     * @param s 字符串11
     * @param x x的位置下标
     * @param x2 交换位的位置下标
     * @return
     */
    public static String swap(String s,int x,int x2){
        StringBuilder str=new StringBuilder(s);
        str.setCharAt(x,s.charAt(x2));
        str.setCharAt(x2,'x');
        return str.toString();
    }
}

俩者区别：

 

进阶少年
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
AcWing | 【DFS】排列数字
Leonadoice的博客
11-11 293
题目内容 给定一个整数n，将数字1~n排成一排，将会有很多种排列方法。 现在，请你按照字典序将所有的排列方法输出。 输入格式 共一行，包含一个整数n。 输出格式 按字典序输出所有排列方案，每个方案占一行。 数据范围 1≤n≤7 输入样例： 3 输出样例： 1 2 3 1 3 2 2 1 3 2 3 1 3 1 2 3 2 1 思路： 完整代码： ...
DFS和BFS笔记
01-20
BFS 先记录广度优先搜索，我理解的广度优先搜索，即是从某点（父结点）出发，按层次遍历后续子节点。如上图所示，我们选取A点为父结点，则接下来应当遍历与A节点直接相邻的B, C节点，我们按顺序将节点记录在python...
DFS【Acwing】
Melody_Gogo的博客
07-04 172
【DFS】1. 排列数字 2. n-皇后
acwing基础课——DFS
qq_62417282的博客
11-30 420
acwing基础课二刷
[Acwing面向模型编程]dfs
玛珈山大萌新
11-03 173
题目1：AcWing 1118. 分成互质组 分析： 枚举每个组，对于当前的组，如果枚举到的数能够放进去，那么就一定放进去（不需要另外开一个新的组），如果当前组无法再放数，则新开辟组。 一开始用的vector，一直t。看来搜索慎用stl 代码： #include <bits/stdc++.h> using namespace std; typedef long long ll;//三年竞赛一场空，不开long long见祖宗 //typedef __int128 lll; #define
acwing算法基础课：DFS
qq_42216575的博客
10-08 142
DFS模板 int dfs(int u) { st[u] = true; // st[u] 表示点u已经被遍历过 for (int i = h[u]; i != -1; i = ne[i]) { int j = e[i]; if (!st[j]) dfs(j); } } 例题 n-皇后问题是指将n今皇后放在n*n的国际象棋棋盘上，使得皇后不能相互攻击到，即任意两个皇后都不能处于同一行、同一列或同一斜线上。 #include <iost
DFS BFS 图.zip_DFS BFS_bfs_bfs dfs_dfs_dfs bfs输出图
09-20
深度优先遍历和广度优先遍历算法实现从定点开始的遍历序列。
DFS和BFS.docx
08-21
我觉得这真的太烂了，只是好玩发上去，大家千万不要打我啊（所以这是免费的）而且相信很多人那你都有这个...
旅游图_dfs_bfs_
09-30
通过bfs和dfs还有其它写的路由图导游应用，可以产生通过整个图的路径和某地到某地的最小路径
BFS和DFS算法可视化（js实现）
01-17
这是山东大学可视化课程项目，用js实现的BFS和DFS，详细的展示了BFS和DFS的运行过程，网页可交互。
Acwing 1076. 迷宫问题 (BFS 记录路径
Minelois的博客
07-21 138
添加链接描述 #include <bits/stdc++.h> using namespace std; const int N = 1e3 + 10; int mp[N][N]; typedef pair<int, int> pii; pii dis[N][N]; int n; int dx[] = {0, 0, 1, -1}; int dy[] = {1, -1, 0, 0}; void bfs() {//倒序记录 正序输出 queue<pii> q;
【ACWing 算法基础】DFS
m0_51139226的博客
08-06 164
N皇后解析。
树的重心（dfs、acwing）
weixin_53469462的博客
05-23 198
题目描述 ： 给定一颗树，书中包含 n 个结点（编号 1∼n ）和 n−1 条无向边。 请你找到树的重心，并输出将重心删除后，剩余各个连通块中点数的最大值。 重心定义：重心是指树中的一个结点，如果将这个点删除后，剩余各个连通块中点数的最大值最小，那么这个节点被称为树的重心。 输入输出格式 ： 输入 第一行包含整数 n，表示树的结点数。 接下来 n−1 行，每行包含两个整数 a 和 b，表示点 a 和点 b 之间存在一条边。 输出 输出一个整数 m，表示将重心删除后，剩余各个连通块中点数的最
AcWing1076迷宫—记录路径—pair，pre，bitset，手动队列—BFS
m0_72522122的博客
11-03 122
它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。数据保证至少存在一条从左上角走到右下角的路径。
acwing算法基础 dfs与bfs
a7546391的博客
10-25 218
不撞南墙不回头，空间复杂度是n，不具有最短路效应，适合一些思路比较奇怪，对空间要求高的题目。从根节点开始向下一层一层的搜索，具有最短路的特点，适用于需要找最短路的题目。
Acwing dfs+回溯专题题解
qq_48344603的博客
07-14 293
17-电话号码的字母组合 其实就是map那个感觉有点麻烦，其他还行 46-全排列 next_permutation函数，产生所有的下一个组合，所以要先升序排序，保证能有所有下一组合 全排列II next_permutation就是返回不重复的，所以可以继续使用 ...
[Acwing提高]DFS连通性模型与搜索顺序
鱼竿钓鱼干
03-08 156
[Acwing提高]DFS连通性模型与搜索顺序 知识点 题目 扩展方式 类型 迷宫 看是否连通 DFS连通性 红与黑 Flood-Fill DFS连通性 马走日 统计路径数 DFS搜索顺序 题目 迷宫 思路 起点不一定能走啊 代码 #include<bits/stdc++.h> using namespace std; const int N=110; char g[N][N]; bool st[N][N]; int n,k; int
[Acwing算法基础] 3.1 dfs暴力搜索
qq_22473333的博客
05-17 277
dfs深度优先搜索分析方法 dfs最重要的使搜索顺序。即使用什么顺序搜索遍历所有方案。以例题842. 排列数字
[AcWing算法刷题]之DFS+BFS迷宫模板（简单）
lihua777的博客
03-26 4948
[AcWing算法刷题]之DFS+BFS迷宫模板（简单）
DFS BFS UCS
最新发布
11-15
以下是对DFS、BFS和UCS的介绍： DFS（深度优先搜索）：总是扩展最深层的节点，使用的是LIFO队列，即使用的是stack栈。DFS在生成节点时做的goal test，因此在搜索树中，DFS总是沿着最深的路径搜索，直到找到目标状态...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值