深度优先 搜索(DFS, Depth First Search)
从一个顶点v出发，首先将v标记为已遍历的顶点，然后选择一个邻接于v的尚未遍历的顶点u，如果u不存在，本次搜素终止。如果u存在，那么从u又开始一次DFS。如此循环直到不存在这样的顶点。
算法核心代码如下：
void dfs(int step){
// 判断边界是否成立
// 尝试每一种可能
for(int i=0;i<n;i++){
//
// 继续执行下一步
dfs(step + 1)
// 取消已被使用标记
}
}
全排列
下面我们利用一个简单基本案例来学习全排列
A 手中有3张牌,分别是1,2,3 那么请问这三张牌能组成多少位不重复三位数字？
DFS算法分析
首先我们假设有三个桶，桶里面可以存放牌，那么我们来到第一个桶，我们手里有3张牌,按照顺序，我我们可以放入1，然后完成当前操作，标记第一张牌已经被使用，来到第二个桶里面，开始尝试，尝试放入第一张牌，此时1已经被使用了，所以我们尝试2，那么第二个桶也已经被放入数据了,2被标记为使用，接着来到第3个桶，此时，我们尝试放入1,1被使用，无法放入，尝试放入2，2也被使用，尝试放入3，OK，3 放入成功，此时三个桶放入完成，完成一次全排列，即
1,2,3好，回到第3个桶，的时候我们没有其他牌可以放了，1，2已经被使用，3正在桶里呢，我们继续回到2号桶，同时标记3号牌未被使用，回到2号桶，此时2号桶已经尝试了1,2 那么我们继续尝试3号牌，3号牌刚刚被收回，可以放入，此时2号桶放入3号牌，继续第3个桶，同样的依次尝试所有的可能，1号牌不行，2号可以，此时完成了全排列
1,3,2继续，回到3号桶，没有可用的了，回到2号桶，3号牌也被用了，也没有了，继续回到1号桶，此时1号桶放入的是1，那么我们收回，继续放入2号牌，来到2号桶，此时手中有1,3号，我们放入1，来到3号桶，1,2已被使用，我们只能放入3，又完成一次全排列
2,1,3依次类推....
那么我们看下代码，这里提供了C语言版本的和Java语言版本的，原理是一样的
C语言版本
代码
#include <stdio.h>
// 定义扑克牌长度 3
#define PLAY_CARD_SIZE 3
// 定义数组
int numbers[] = {1,2,3};
// 标记数字是否被使用
int status[] = {0, 0, 0};
// 定义位置
int location[] = {0,0,0};
/**
* 声明dfs方法
* @param step 当然位置
*/
void dfs(int step);
int main(){
dfs(0);
return 0;
}
void dfs(int step){
// 判断搜索临界条件
if (step == 3){
for (int i = 0; i < 3; ++i) {
printf("%d,",location[i]);
}
printf("\n");
// 完成此次全排列
return;
}
for (int j = 0; j < 3; ++j) {
if(status[j] == 0){
location[step] = numbers[j];
status[j] = 1;
dfs(step + 1);
status[j] = 0;
}
}
}
输出结果
1,2,3,
1,3,2,
2,1,3,
2,3,1,
3,1,2,
3,2,1,
Java语言版本
代码
import java.util.ArrayList;
import java.util.List;
/**
* 深度优先搜寻算法
*/
public class DFS2 {
// 定义扑克牌的数量
static int PLAY_CARD_SIZE = 3;
// 存放扑克牌的集合
static List<PlayCard> playCards = new ArrayList<>();
// 存放扑克牌的位置
static String[] numbers = new String[PLAY_CARD_SIZE];
// 初始化扑克牌 1,2,3
static {
for (int i = 0; i < PLAY_CARD_SIZE; i++) {
playCards.add(new PlayCard(String.valueOf(i + 1), false));
}
}
// 程序入口
public static void main(String[] args) {
dfs(0);
}
private static void dfs(int startIndex) {
if (startIndex == playCards.size()){
for (int i = 0;i<numbers.length;i++){
System.out.print(numbers[i]+",");
}
System.out.println("");
System.out.println("-------------");
return;
}
for (int i = 0; i < playCards.size(); i++) {
if(!playCards.get(i).used){
playCards.get(i).used = true;
numbers[startIndex] = playCards.get(i).code;
dfs(startIndex + 1);
playCards.get(i).used = false;
}
}
}
// 封装的实体类，为了方便定义为public
static class PlayCard {
public PlayCard(String code, boolean used) {
this.code = code;
this.used = used;
}
// 扑克牌编号 ，即1,2,3
public String code;
// 扑克牌是否已被使用
public boolean used;
}
}
输出结果
1,2,3,
1,3,2,
2,1,3,
2,3,1,
3,1,2,
3,2,1,
等式求解
想起来以前有个题目，计算恒等式，题目是a[0] * 100 + a[1] * 10 + a[2] +a[3] * 100 + a[4] * 10 + a[5] == a[6] * 100 + a[7] * 10 +a[8] 问a的组合有多少种？
Ps:a是0-9组成的，不可重复
下面我们有DFS来实现这个题目，记得在以前，肯定是写九个for循环嵌套,现在我们尝试利用上面的全排列来判断，此时的输出(边界条件)修改为上面的等式，代码不做过多的阐述了。没有了9层循环的样子。。。。
代码
public class DFS3 {
static int PLAY_CARD_SIZE = 9;
static List<Number> playCards = new ArrayList<>();
static int[] a = new int[PLAY_CARD_SIZE];
static {
for (int i = 1; i <= PLAY_CARD_SIZE; i++) {
playCards.add(new Number(i, false));
}
}
public static void main(String[] args) {
dfs(0);
}
private static void dfs(int startIndex) {
if (startIndex == playCards.size()) {
if (checkNumber()) {
for (int i=0;i<PLAY_CARD_SIZE;i++){
System.out.print(a[i]+",");
}
System.out.println();
}
return;
}
for (int i = 0; i < playCards.size(); i++) {
if (!playCards.get(i).used) {
playCards.get(i).used = true;
a[startIndex] = playCards.get(i).code;
dfs(startIndex + 1);
playCards.get(i).used = false;
}
}
}
/**
* 判断搜索边界
*
* @return
*/
private static boolean checkNumber() {
if(a[0] * 100 + a[1] * 10 + a[2] +a[3] * 100 + a[4] * 10 + a[5] == a[6] * 100 + a[7] * 10 +a[8])
return true;
return false;
}
static class Number {
public Number(int code, boolean used) {
this.code = code;
this.used = used;
}
public int code;
public boolean used;
}
}
输出结构
输出结构也是蛮多的，这里摘录几个，可以自己测试下
1,2,4,6,5,9,7,8,3,
...
2,1,4,5,6,9,7,8,3,
...
3,1,4,6,5,8,9,7,2,
...
4,1,5,2,7,8,6,9,3,
...
5,9,6,2,4,1,8,3,7,
...
6,9,5,1,4,2,8,3,7,
...
7,8,4,1,5,2,9,3,6,
总结
DFS 是一个非常有意思的算法，在图解中和BFS也属于非常重要的算法了，多多理解，多多学习