深度优先搜索

package com.lishilin; import com.sun.istack.internal.NotNull; import java.util.*; public class Dfs { public static class Node implements Comparable<Node> { private String name; private TreeSet<Node> set = new TreeSet<>();//有序的集合 public Node() { } public Node(String name) { this.name = name; } public String getName() { return name; } public void setName(String name) { this.name = name; } public Set<Node> getSet() { return set; } public void setSet(TreeSet<Node> set) { this.set = set; } @Override public int compareTo(@NotNull Node o) {//排序规则 if(name.hashCode()>o.getName().hashCode()) return 1;

上一节课我们介绍了有关图的基本操作，那么除了上节课我们介绍的那些相关基本操作之外，还有一种非常重要的操作就是有关图的遍历。那么图的遍历分为两种，有广度优先搜索，也就是广度优先遍历。还有深度优先搜索。本节课我们就来学习图的广度优先搜索。 来源： https://www.cnblogs.com/ZHONGZHENHUA/p/11407786.html

最近几天在洛谷上练习搜索类的题目，虽然效率极其低下，但慢慢还是摸索出一些深度及广度搜素的套路。现在来总结几道深度优先搜索的模板题。 1、经典的八皇后问题： 输入：方阵的大小n， 输出：前三行输出前三种方式（每行的皇后的列标），第四行输出方法总数； 思想：以列为单位放置皇后，放置一个皇后之后，标记上此皇后所在行、两条斜线；下一次放置之前则先判断当前所在行、两条斜线有没有被标记；此题需要搞清楚所在两条斜线的坐标特点。右上的斜线上每个点所在横纵坐标之和都相等；左下的斜线横纵坐标之差相等。因此此题需要用三种不同的标记。 题目代码： 1 #include<bits/stdc++.h> 2 using namespace std; 3 bool flag[4][50]={0};//flag[1]代表所在行被标记，flag[2]代表右下斜线，flag[3]标记左上的斜线 4 int n,sum=0;//n代表方阵大小,sum代表解法的总数 5 int ans[50];//保存每次选择的列坐标 6 7 void dfs(int i){ 8 int j; 9 if(i>n){//所有列都访问完即为一种方法 10 ++sum; 11 if(sum>3)return ; 12 else 13 { 14 for(int i=1;i<=n;++i) 15 printf("%d ",ans[i]); 16

深度搜索 // ---------------------------------------------------------------- // 图的深度优先搜索法 // ---------------------------------------------------------------- #include " iostream " #include " stdlib.h " using namespace std; struct node // 图顶点结构声明 { int vertex; // 顶点数据 struct node * nextnode; // 指下一顶点的指针 }; typedef struct node * graph; // 图的结构新类型 struct node head[ 9 ]; // 图的顶点结构数组 int visited[ 9 ]; // 顶点记录数组 // ----------------------------------------------------------------- // 创建图 // ----------------------------------------------------------------- void creategraph( int * node, int num) { graph

广度优先搜索 typedef struct { int que[MaxVertexNum]; int rear,front; }Queue;//广度优先搜索队列的存储结构 int visit[MaxVertexNum];//全局变量数组 void BFS(MGraph &M,int v){ printf("广度优先搜索:"); Queue q; int v1; for(int i=0;i<MaxVertexNum;i++){ visit[i]=0; } q.rear=0; q.front=0; q.que[q.rear++]=v; visit[v]=1; visited(v); while(q.front!=q.rear){ v1=q.que[q.front++]; for(int j=0;j<M.vertexnum;j++){ if(M.Edge[v1][j]!=0&&visit[j]==0){ q.que[q.rear++]=j; visited(j); visit[j]=1; } } } } 深度优先搜索 来源： https://www.cnblogs.com/Yshun/p/11374038.html

Leetcode之深度优先搜索&回溯专题-491. 递增子序列（Increasing Subsequences） 深度优先搜索的解题详细介绍， 点击 给定一个整型数组, 你的任务是找到所有该数组的递增子序列，递增子序列的长度至少是2。 示例: 输入: [4, 6, 7, 7] 输出: [[4, 6], [4, 7], [4, 6, 7], [4, 6, 7, 7], [6, 7], [6, 7, 7], [7,7], [4,7,7]] 说明: 给定数组的长度不会超过15。 数组中的整数范围是 [-100,100]。 给定数组中可能包含重复数字，相等的数字应该被视为递增的一种情况。 从第一个元素进入，取大于等于list最后一个元素的数字，再回溯。 AC代码： class Solution { Set<List<Integer>> ans = new HashSet<>(); public List<List<Integer>> findSubsequences(int[] nums) { if(nums.length==0 || nums==null) return new ArrayList<>(ans); dfs(nums,0,new ArrayList<Integer>()); return new ArrayList<>(ans); } private void dfs

Leetcode之深度优先搜索&回溯专题-980. 不同路径 III（Unique Paths III） 深度优先搜索的解题详细介绍， 点击 在二维网格 grid 上，有 4 种类型的方格： 1 表示起始方格。且只有一个起始方格。 2 表示结束方格，且只有一个结束方格。 0 表示我们可以走过的空方格。 -1 表示我们无法跨越的障碍。 返回在四个方向（上、下、左、右）上行走时，从起始方格到结束方格的不同路径的数目，每一个无障碍方格都要通过一次。 示例 1： 输入：[[1,0,0,0],[0,0,0,0],[0,0,2,-1]] 输出：2 解释：我们有以下两条路径： 1. (0,0),(0,1),(0,2),(0,3),(1,3),(1,2),(1,1),(1,0),(2,0),(2,1),(2,2) 2. (0,0),(1,0),(2,0),(2,1),(1,1),(0,1),(0,2),(0,3),(1,3),(1,2),(2,2) 示例 2： 输入：[[1,0,0,0],[0,0,0,0],[0,0,0,2]] 输出：4 解释：我们有以下四条路径： 1. (0,0),(0,1),(0,2),(0,3),(1,3),(1,2),(1,1),(1,0),(2,0),(2,1),(2,2),(2,3) 2. (0,0),(0,1),(1,1),(1,0),(2,0),(2,1),(2

Leetcode之深度优先搜索&回溯专题-679. 24 点游戏（24 Game） 深度优先搜索的解题详细介绍， 点击 你有 4 张写有 1 到 9 数字的牌。你需要判断是否能通过 * ， / ， + ， - ， ( ， ) 的运算得到 24。 示例 1: 输入: [4, 1, 8, 7] 输出: True 解释: (8-4) * (7-1) = 24 示例 2: 输入: [1, 2, 1, 2] 输出: False 注意: 除法运算符 / 表示实数除法，而不是整数除法。例如 4 / (1 - 2/3) = 12 。 每个运算符对两个数进行运算。特别是我们不能用 - 作为一元运算符。例如， [1, 1, 1, 1] 作为输入时，表达式 -1 - 1 - 1 - 1 是不允许的。 你不能将数字连接在一起。例如，输入为 [1, 2, 1, 2] 时，不能写成 12 + 12 。 　　　　　　 分析： 给定4元组，求如何使用 + - * / ( ) 来组合它们，使最后的值等于24. 思路： 从元组里选出2个 把这2个进行加减乘除操作 把元组中未选中的加入其中 再次从该元组中选2个 依此类推- 直到元组中只剩下1个元素时进行判断 代码中有几个点需要注意： 要把int数组转成double 判断数字是否等于24的方法，是看误差是否小于10 6 从数组中取2个数字后，new一个新的元组

深度优先搜索DFS 所谓深度优先搜索，通俗点理解就是一条路走到头--不撞南墙不回头。 我们先来看一个全排列问题，现在要对1 2 3进行全排列，现在小哼手上拿着1 2 3三张卡片，他要将这三张卡片放入三个盒子里，每放满不就是一种全排列了么？ 但是每次到底是先放卡片1还是卡片2，3呢？ 小哼想，我按顺序放吧，每次都按照1.2.3的顺序放卡片。于是他走到1号盒子前把卡片1放入，走到2号盒子前把卡片2放入，走到3号盒子前把卡片3放入，走到四号盒子...但小哼的卡片已经放完 啦。这时就产生了一种全排列“ 1 2 3 ”啦。 但是还有好多种情况啊，于是产生了一种全排列后小哼要立即返回，他回到3号盒子前，将卡片3取回，看还能不能放其他卡片，显现小哼现在手里没除了卡片3外没有其他卡片了，所以小哼继续 往后退，到了2号盒子前，小哼将卡片2收回，这是小哼手里已经有两张卡片了，于是他将卡片3放入2号盒子，放好后又往后走一步来到三号盒子，将卡片2放入，又来到四号盒子前，当然没有 四号盒子啦，于是又产生了一种全排列“ 1 3 2 ” 按照这样模拟后，便会依次生成全排列 “2 1 3” “2 3 1” “3 1 2” “3 2 1” 说了半天，我们看下如何用代码实现吧 先将i号卡片放入第step个盒子中 for(i = 1; i <=n; i++) { a[step] = i; /

深度优先搜索算法（英语：Depth-First-Search，简称DFS）是一种用于遍历或搜索树或图的算法。 沿着树的深度遍历树的节点，尽可能深的搜索树的分支。当节点v的所在边都己被探寻过或者在搜寻时结点不满足条件，搜索将回溯到发现节点v的那条边的起始节点。整个进程反复进行直到所有节点都被访问为止。属于盲目搜索,最糟糕的情况算法时间复杂度为O(!n)。（Wiki） （直到走不下去才往回走） 基本模板 int search(int t) { if(满足输出条件) { 输出解; } else { for(int i=1;i<=尝试方法数;i++) if(满足进一步搜索条件) { 为进一步搜索所需要的状态打上标记; search(t+1); 恢复到打标记前的状态;//也就是说的{回溯一步} } } } 1.全排列问题（leetcode.46）： 给定一个没有重复数字的序列，返回其所有可能的全排列。 示例: 输入: [1,2,3] 输出: [[1,2,3],[1,3,2], [2,1,3], [2,3,1],[3,1,2],[3,2,1]] 思路分析 ： 这是一个非常典型的使用 回溯算法 解决的问题。解决回溯问题， 一定不要偷懒，拿起纸和笔，画出一个树形结构，思路和代码就会比较清晰了 。 方法：回溯算法（深度优先遍历+状态重置） 以示例 [1,2,3] 为例，因为是排列问题