【算法】深搜和广搜
深搜和广搜
1.概念
- 深度优先搜索（Depth First Search, DFS）：“不撞南墙不回头”
- 广度优先搜索（Breath First Search, BFS）：“一石激起千层浪”
2.DFS
2.1 特点
- 深度优先搜索的主要思路是从一个未访问过的节点开始，沿着一条路一直走，直到走到头后没法再走了，这时候回退到上一个节点，然后再换下一个节点接着走，不断地去重复这个过程，直到所有的节点都走完，很明显，DFS的特点就是不撞南墙不回头，先走完一条路，再换下一条路接着走。
- 通过上面的叙述，发现DFS其实很多时候是和递归一起出现的，但凡是递归的，当然也可以用非递归的方法来实现，其实就是利用栈这个结构，
- DFS常用于寻找所有解的问题，需要记录并且完成整个搜索，所以很多时候需要去进行剪枝
2.1 典例-树
先来看一下树的DFS，例如要遍历上面那棵树，DFS就是一条路走到黑，然后走不动往上个路口回，然后看有没有其他选择
递归实现
public class Solution {
private static class Node {
public int value;
public Node left;
public Node right;
public Node(int value, Node left, Node right) {
this.value = value;
this.left = left;
this.right = right;
}
}
public static void dfs(Node treeNode) {
if (treeNode == null) {
return;
}
// 遍历节点
process(treeNode)
// 遍历左节点
dfs(treeNode.left);
// 遍历右节点
dfs(treeNode.right);
}
}
非递归实现
压入根节点
1.弹出就打印
2.if有右孩子，压入右孩子
3.if有左孩子，压入左孩子
重复1.2.3
/**
* 使用栈来实现 dfs
* @param root
*/
public static void dfsWithStack(Node root) {
if (root == null) {
return;
}
Stack<Node> stack = new Stack<>();
// 先把根节点压栈
stack.push(root);
while (!stack.isEmpty()) {
Node treeNode = stack.pop();
// 遍历节点
process(treeNode)
// 先压右节点
if (treeNode.right != null) {
stack.push(treeNode.right);
}
// 再压左节点
if (treeNode.left != null) {
stack.push(treeNode.left);
}
}
}
2.3 典例-图
思路
假设上幅图片要从起点（黑色）走到终点（红色），找一条路径。
if要用深度优先搜索的例子来解这道题，那对于每一个格子，都有上下左右四个方向，从这个起始的位置可以发现，我们可以按照左->下->右->上这样的顺序去走路，也就是if左边能走，那就往左边走，到了下一个格子后，if左边能走，那接着走，if左边不能走了，那就看看下边能不能走，依次进行，if四个方向都不能走了，那就需要回溯到上一个，然后再看上一个的其他方向能不能走；
具体到这个图中：先向左走1格-》再向左走一格-》左边无法走，下边无法走，上边无法走，右边走过了，无路可走-》这条路死路解决不了问题-》回到上一个位置-》同样无路可走再回退-》到起点后，左边证明不行了，往下走-》。。。。重复这个过程
- 深度优先的特点就是不管有多少岔路口，都先选一条路走到底，不成功就返回上一个路口选择下一条路，
程序实现
int goal_x = 9, goal_y = 9 //目标坐标
int n = 10, m = 10 //地图的长宽
int graph[n][m]
int used[n][m]
int px = {-1, 0, 1, 0}
int py = {0, -1. 0, 1} //通过这两个来进行左下右中的移动
int flag = 0 //到达终点的标志
void DFS(in graph[][], int used[][], int x, int y)
{
//if目标相同，那证明成功
if(graph[x][y] == graph[goal_x][goal_y]){
print("successful")
flag = 1
return
}
//向四个方向遍历
for(int i = 0, i < 4, i++){
int new_x = x+px[i], new_y = y + py[i]
if(new_x >= 0 && new_x < n && new_y >= 0 && new_y < m && used[new_x][new_y] == 0 && !flag) { //没有且满足边界的时候
used[new_x][new_y] = 1 //走这个格子
DFS(graph, used, new_x, new_y) //接着以这个格子接着走
used[new_x][new_y] = 0 //回溯设置为0
}
}
}
3.BFS
3.1 特点
- 广度优先搜索的主要思路是从一个或多个未访问过的节点开始，先遍历这个节点的所有相邻节点，再遍历每个相邻节点的相邻节点。BFS的特点是一石激起千层浪，从一个节点开始向外扩散。
- DFS是和递归或者说是栈一起出现的，而BFS很多时候其实是和队列一起出现的。这就是两者的区别。
- BFS常用于寻找单一的最短路径问题，特点是：搜到就是最优解
3.2 典例-树
仍然是上面第一个例子，我们换一种遍历思路，刚才是从一条路先走到头，这次一层一层的遍历，这就是bfs
程序实现
/**
* 使用队列实现 bfs
* @param root
*/
private static void bfs(Node root) {
if (root == null) {
return;
}
Queue<Node> stack = new LinkedList<>();
stack.add(root);
while (!stack.isEmpty()) {
Node node = stack.poll();
System.out.println("value = " + node.value);
Node left = node.left;
if (left != null) {
stack.add(left);
}
Node right = node.right;
if (right != null) {
stack.add(right);
}
}
}
3.3 典例-图
思路
- 广度优先在面临岔路口的时候，会把所有路口都记住，然后向着外面去进行扩散。
程序实现
int n = 10, m = 10;
void BFS(){
queue que //用队列来进行保存
int graph[n][m]
int px[] = {-1, 0, 1, 0}
int py[] = {0, -1, 0, 1}
que.push(起点入队）；
while(!que.isEmpty()){
temp = que.pop();
for(int i = 0; i < 4; i++){
if(可以走）{
//标记当前格子
//入队
}
4.总结
- 在树里，用的比较多的是dfs，因为树只有两个节点，并且有明显的路径（向左或者向右），可以直接使用递归的方法一次性走完；但是在图里，用到较多的是bfs，对于树而言，队列里存的是当前层的节点；对于图而言，当前队列里存的是所有的邻居节点。
BFS的框架
//计算起点start到终点target的最小距离
int BDS(Node start, Node target){
Queue<Node> queue; //核心结构：队列；
Set<Node> visited; //在图中都会用到，因为存在着交叉，会走回头路，树中则不需要，因为有next指针；
queue.offer(start); //起点入队；
visited.add(start);
int step = 0; //记录扩散步数；
while(queue.isEmpty()){
int size = queue.size();
//从当前队列中所有节点向与其关联的节点扩散；
for(int i = 0; i < size; i++){
Node cur = queue.poll();
if(cur == target){
return step; //注意不同题目里这里的判断条件，是否到达终点；
}
for(Node x : cur.adj()){ //这里指的是当前节点的邻居节点；
if(!visited.contains(x)){ //还没走过再加入；不走回头路；
queue.offer(x);
visited.add(x);
}
}
}
step++; //注意在这里更新步数；
}
}
