dfs

深度优先搜索算法（英语：Depth-First-Search，简称DFS）是一种用于遍历或搜索树或图的算法。 沿着树的深度遍历树的节点，尽可能深的搜索树的分支。当节点v的所在边都己被探寻过或者在搜寻时结点不满足条件，搜索将回溯到发现节点v的那条边的起始节点。整个进程反复进行直到所有节点都被访问为止。属于盲目搜索,最糟糕的情况算法时间复杂度为O(!n)。（直到走不下去才往回走） 基本模板 1 int check(参数) 2 { 3 if(满足条件) 4 return 1; 5 return 0; 6 } 7 8 void dfs(int step) 9 { 10 判断边界 11 { 12 相应操作 13 } 14 尝试每一种可能 15 { 16 满足check条件 17 标记 18 继续下一步dfs(step+1) 19 恢复初始状态（回溯的时候要用到） 20 } 21 } 实例 1、全排列（字符串内元素的所有排列方法）（洛谷CF6A与此题类似） 1 //全排列问题 2 #include<stdio.h> 3 #include<string.h> 4 5 int n; 6 char a[15]; 7 char re[15]; 8 int vis[15]; 9 //假设有n个字符要排列，把他们依次放到n个箱子中 10 //先要检查箱子是否为空，手中还有什么字符，把他们放进并标记。 11

1 vector<int> p[MAX]; 2 int V; 3 int color[MAX]; 4 5 bool dfs(int v,int c) 6 { 7 color[v]=c; 8 for(int i=0; i<p[v].size(); i++){ 9 if(color[p[v][i]==c) return false; 10 if(color[p[v][i]==0 && !(dfs(p[v][i],-c))) return false; 11 } 12 return true; 13 } 14 15 void solve() 16 { 17 for(int i=0; i<V; i++){ 18 if(color[i]==0){ 19 if(dfs(i,1)){ 20 printf("YES\n"); 21 return ; 22 } 23 } 24 } 25 printf("NO\n"); 26 } 来源： https://www.cnblogs.com/wangmengmeng/p/5263273.html

题目 题目 代码实现 /* * POJ 3009: Curling 2.0 * 题意：m＊n矩阵中，给出起点、终点、空格、障碍，从每个点可向4方前进，直到遇到障碍，打碎并停在障碍格的前面。求到达终点的最少前进次数。 * 类型：DFS＋记忆化搜索 * 算法：从某点出发，向4个方向投掷，遇到障碍格，标记其为空格状态，继续递归障碍前一点，回退恢复障碍状态。每次递归直至到达终点或全部出界失败。 */ #include <cstdio> #include <cstring> #include <iostream> using namespace std; const int INF = 1000; const int TYPE_VACANT = 0; const int TYPE_BLOCK = 1; const int TYPE_START = 2; const int TYPE_GOAL = 3; const int MAX_THROW = 10; int m, n; int mat[22][22]; int dx[4] = {-1, 0, 1, 0}; int dy[4] = {0, 1, 0, -1}; int ans; void dfs(int x, int y, int step) { if(step >= MAX_THROW) { return; } for(int i = 0

http://bailian.openjudge.cn/practice/4070 next_permutation(); # include <iostream> # include <cstdio> # include <cstring> # include <algorithm> # define ll long long using namespace std ; int a [ 10 ] ; int main ( ) { ios :: sync_with_stdio ( false ) ; int n ; while ( cin >> n , n ) { for ( int i = 0 ; i < n ; i ++ ) a [ i ] = i + 1 ; do { for ( int i = 0 ; i < n ; i ++ ) printf ( "%d%c" , a [ i ] , i == n - 1 ? '\n' : ' ' ) ; } while ( next_permutation ( a , a + n ) ) ; } return 0 ; } # include <iostream> # include <cstdio> # include <cstring> # include <algorithm> # define ll long long using

http://www.pipioj.online/problem.php?id=1033 题目描述 PiPi喜欢把别人的名字拆开来，比如“螺”就可以拆成“虫田糸”，PiPi的语文学的不是很好，于是她决定使用编程的方式来解决这个问题。 给出一个01矩阵，1占据的部分即为需要拆的字，如果两个1分享一条边，那么它们连通。连通具有传递性，即如果a、b连通，b、c连通，则a、c连通。 连通的一系列1被看做可以拆出的一块，现在PiPi需要输出这些拆出的块（用一个01矩阵表示，并且要求矩阵的大小尽可能的小）。 为了确保输出的顺序尽可能的和书写的顺序一致，PiPi从每个块中选出最左上角的点（最左侧的点中，最靠上的）作为代表点，然后按照代表点从左到右（若相同则按从上到下）的顺序输出所有拆出的块。 输入 多组数据。 输入的第一行为两个正整数N、M，表示01矩阵的大小。 接下来N行，每行M个01字符，描述一个需要拆的字。 对于40%的数据，满足1<=N,M<=10。 对于100%的数据，满足1<=N,M<=500。 额外的样例： 11 17 00000000000000000 00001111111100000 00000000000000000 00111111111111100 00000000100000000 00000010101110000 00000110100011000

题目标签：Backtracking 　　用dfs，只对字母分别递归小写 和 大写，具体看code。 　　 Java Solution: Runtime: 1 ms, faster than 100.00 % Memory Usage: 42.7 MB, less than 8.00 % 完成日期：12/15/2019 关键点：dfs class Solution { public List<String> letterCasePermutation(String S) { List<String> result = new ArrayList<>(); DFS(result, S.toCharArray(), 0); return result; } private void DFS(List<String> res, char [] cArr, int pos) { if(pos == cArr.length) { res.add(new String(cArr)); return; } if(Character.isLetter(cArr[pos])) { // lower case cArr[pos] = Character.toLowerCase(cArr[pos]); DFS(res, cArr, pos+1); // upper case cArr[pos] =

本文始发于个人公众号： TechFlow ，原创不易，求个关注 在之前周末LeetCode专栏当中，我们详细描述了深度优先搜索和回溯法，所以今天我们继续这个话题，来和大家聊聊搜索算法的另一个分支，广度优先搜索。 广度优先搜索的英文是Breadth First Search，简写为bfs。与它相对的深度优先搜索，英文自然就是Depth First Search，简写成dfs。所以如果在阅读我或者其他人的代码时发现有个函数叫做bfs或者dfs，如果你能回忆起这些英文缩写，一定可以明白它们是什么意思。 bfs与dfs 在讲解bfs的概念之前，我们先来回顾一下dfs的概念，好有个对比。 通过之前的文章，我们已经知道了实现dfs往往需要使用递归。我们在一次递归当中需要遍历当前所有的决策，然后递归去执行这些决策。如果这些决策会对未来的决策产生影响，那么我们还需要使用回溯法，在决策遍历结束之后，撤销当前的操作。 所以我们有了dfs的模板代码： def dfs(n): if n > depth: return for i in decisions: do_decision(i) dfs(n+1) rollback(i) 假如我们有一棵树，我们需要遍历树。显然由于树是由节点组成的树形结构，不是list结构，所以我们并不能直接用循环来遍历。为了避免重复，我们需要按照一定的顺序在树上遍历

不会数位dp的同学点这里 数位dp教学 # include <bits/stdc++.h> using namespace std ; # define ll long long # define lb long double # define INF 0x3f3f3f3f const int maxn = 100035 ; const int mod = 1e6 + 7 ; int len ; ll dp [ 15 ] [ 2 ] [ 2 ] [ 12 ] [ 10 ] ; // dp[i][j][k][l][m]表示当前搜到第i位，且前导0与最高位限制状态为j和k, 且要统计的数字是l， 并且已经产生m个dig的答案 int a [ 15 ] ; // pos代表当前搜到第几位，lead表示有无前导0， limit表示当前位是有限制， dig表示要统计是的数字， sum表示已经产生的dig的数量 ll dfs ( int pos , int lead , int limit , int dig , int sum ) { if ( pos > len ) return sum ; // 如果搜完了所有位数则返回答案sum if ( ! limit && ! lead && dp [ pos ] [ lead ] [ limit ] [ dig ] [ sum ] != - 1

常规搜索题。给一个矩阵，有些点不能走，计算从起点到终点的最短路径的长度。 注意： 矩阵范围为100*100，DFS+剪枝也会超时（但理论上最坏情况都是O(n^2)，可能是测试点的问题？专门不让DFS过） DFS模板：把终止条件和剪枝放在函数头，然后依次访问四个方向，先判断再标记进入，回溯。 # include <iostream> int H , L , step = 0 , min = 100000 , X [ 4 ] = { 0 , 1 , 0 , - 1 } , Y [ 4 ] = { - 1 , 0 , 1 , 0 } , sh , sl ; char maze [ 110 ] [ 110 ] ; bool mark [ 110 ] [ 110 ] ; void dfs ( int h , int l , int step ) { if ( step >= min ) return ; if ( maze [ h ] [ l ] == 'T' ) { if ( step < min ) min = step ; return ; } for ( int i = 0 ; i < 4 ; i ++ ) { int hh = h + Y [ i ] , ll = l + X [ i ] ; if ( ( maze [ hh ] [ ll ] == '.' || maze [ hh

对一个 \(n\times n\) 的棋盘，每个格子上有一个字母，表示遇到这个格子就向着某个方向走或者停止。现在给定从每个位置开始会走到的位置，或者死循环，试构造一个合法的棋盘，或者输出 INVALID。 Solution 除去死循环的部分，终点相同的点会形成独立的联通块，我们从终点开始反向 DFS 即可 如果死循环是单独的一个点，则 INVALID 否则，我们强行构造出一个二元环，然后当做第一种情况做即可 #include <bits/stdc++.h> using namespace std; const int N = 1005; char a[N][N]; int n,x[N][N],y[N][N]; void dfs1(int i,int j,int ii,int jj) { if(x[i-1][j]==ii && y[i-1][j]==jj && a[i-1][j]==0) { a[i-1][j]='D'; dfs1(i-1,j,ii,jj); } if(x[i+1][j]==ii && y[i+1][j]==jj && a[i+1][j]==0) { a[i+1][j]='U'; dfs1(i+1,j,ii,jj); } if(x[i][j-1]==ii && y[i][j-1]==jj && a[i][j-1]==0) { a[i][j-1]='R'; dfs1(i