深度优先搜索

​ 有一个问题，输入一个数n，输出1~n的全排列。这里先将这个问题形象化，举个例子。假如有编号为1、2、3的3张扑克牌和编号为1、2、3的3个盒子，现在需要将这3张扑克牌分别放到3个盒子中，并且每个盒子只能放一张扑克牌。那么一共有多少种方法呢？

​ 现在让A先来，A手里有3张扑克牌，首先走到1号盒子面前，此时A心里想：他是要先放1号扑克牌，还是2号扑克牌，还是3号扑克牌呢？现在要生产的全排列，很显然3种方式都要去尝试。那么现在就先约定好一个顺序先：每次走到一个盒子面前都先放1号，再放2号，最后才来放3号。

​ 现在A先到1号盒子面前放下1号扑克牌，再去2号盒子面前放下2号扑克牌，然后在3号盒子面前放下3号扑克牌，此时就已经完成了一种排列了，盒子中的扑克牌号码排序为1 2 3。

​ 那么是不是就到此技术了呢，那必然是没有的，因为要求的是全排列，产生了这一种排列之后需要理解返回，现在需要返回一步到2号盒子面前，此时手里还有两张扑克牌，刚刚已经先放过2号扑克牌了，那么这次就需要先放3号扑克牌了，那么现在的排序就是1 3 2。这又是一种新的牌序。

​ 按照刚刚的步骤反复去模拟，变回依次产生所有的排列：2 1 3， 2 3 1， 3 1 2， 3 2 1。

​ 说完了过程之后，这个过程要怎么使用程序来实现呢？现在要解决的最基本的问题：如何往盒子里面去放扑克牌。每一个盒子里面有可能会放入1,2,3号扑克牌，这就需要一一的去尝试，这里一个for循环就可以解决这个问题：

for (i = 1; i <= n; i++) {
    a[step] = i;
}

​ 这个数组a在这里是用来表示盒子的，变量step是用来表示现在处于第step个盒子面前的，现在就又有一个新问题了，这个扑克牌放入盒子里面之后这个扑克牌就不在手中了，就无法再放入其他的盒子了。因此还需要一个数组book来标记哪些牌是已经使用过的了。

for (i = 1; i <= n; i++) {
    if (book[i] == 0) {
        a[step] = i;
        book[i] = 1;
    }
}

​ OK，现在已经是处理完第step个小盒子了，接下来就需要往下走一步，继续处理第step+1个盒子。那么何如处理这第step+1个盒子呢？处理方法其实和刚刚处理第step个盒子相同。因此可以把刚刚处理第step个盒子的代码封装为一个函数，可以把这个函数就命名为DFS，如下：

void DFS(int step)
{
    for (i = 1; i <= n; i++) {
        // 判断扑克牌是否还在手上
        if (book[i] == 0) {
            a[step] = i;
            book[i] = 1;
        }
    }
    
    return;
}

​ 把这个过程写成函数，刚才的问题就好办了。在处理完第step个盒子后，紧接着就处理第step+1个盒子，直接调用函数DFS输入参数为step和step+1即可。

void DFS(int step)
{
    for (i = 1; i <= n; i++) {
        if (book[i] == 0) {
            a[step] = i;
            book[i] = 1;
            DFS(step + 1); // 通过递归调用实现
            book[i] = 0; // 非常重要的一步，一定要把刚刚尝试的扑克牌资源回收，这样才能进行下一次尝试
        }
    }
    return;
}

​ 上面代码中的book[i] = 0;这一句非常的重要，这句话的作用就是将盒子中的扑克牌进行回收，因为在执行完上一次摆放结束后返回的时候，如果不把刚刚放入盒子中的扑克牌回收，那么将无法进行下一次的尝试摆放。

​ 那么还剩下最后一个问题，就是什么时候输出一个满足要求的序列呢？其实当我们在处理第n+1个盒子的时候，那么就相当于说明前面n个盒子都已经摆放好了，这里就是将1~n个盒子中的扑克牌编号打印出来就行了，打印完了之后一定要立即return，不然这个程序就会永无止境的运行下去了。

void DFS(int step)
{
    if (step == n + 1) {
        // 输出一种排列方法
        for (i = 1; i <= n; i++) {
            printf("%d", a[i]);
        }
        printf("\n");
        
        return; // 返回之前的一步
    }
    
    for (i = 1; i <= n; i++) {
        // 判断扑克牌是否在手上
        if (book[i] == 0) {
            a[step] = i;
            book[i] = 1;
            DFS(step + 1); // 通过递归调用实现
            book[i] = 0; // 非常重要的一步，一定要把刚刚尝试的扑克牌资源回收，这样才能进行下一次尝试
        }
    }
    
    return;
}

完整代码如下：

#include <stdio.h>
int a[10], book[10], n;

void DFS(int step)
{
    int i;
    if (step == n) {
        // 输出一种排列方法
        for (i = 1; i <= n; i++) {
            printf("%d", a[i]);
        }
        printf("\n");
        
        return; // 返回之前的一步
    }
    
    for (i =1; i <= n; i++) {
        // 判断扑克牌是否在手上
        if (book[i] == 0) {
            a[step] = i;
            book[i] = 1;
            DFS(step + 1); // 通过递归调用实现
            book[i] = 0; // 非常重要的一步，一定要把刚刚尝试的扑克牌资源回收，这样才能进行下一次尝试
        }
    }
    
    return;
}

int main()
{
    scanf("%d", &n);
    DFS(1);
    return 0;
}

​ 这是个简单的实例，核心代码不超过20行，但是应该是饱含了DFS的基本模型。理解深度优先搜索的关键在于解决“当下该如何做”。至于下一步该如何做，则与当下该如何做是一样的。比如这个DFS函数中的主要功能就是解决你当你在step盒子时你该怎么做。通常的办法就是把每一种可能都去尝试一遍。当前这一步解决后就能进入下一步DFS(step+1)。下一步的解决方法和当前这一步的结局方法是完全一样的。

​ 现在就可以使用这个方法来解决一个xxx + xxx = xxx的问题了，这就相当于你手中有1~9的9张扑克牌，然后放到9个盒子里面去，并使得xxx + xxx = xxx成立。其实也就是判断一下a[0] * 100 + a[1] *10 + a[2] + a[3] * 100 + a[4] *10 + a[5] = a [6] * 100 + a[7] *10 + a[8]是否成立的问题了。

#include <stdio.h>
int a[10], book[10], total = 0;

void DFS(int step)
{
    int i;
    if (step == 10) {
        // 判断是否满足条件
        if (a[1] * 100 + a[2] * 10 + a[3] + a[4] * 100 + a[5] * 10 + a[6] == a[7] * 100 + a[8] * 10 + a[9]) {
            total++;
            printf("%d%d%d + %d%d%d = %d%d%d\n", a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9]);
        }
        return;
    }
    
    for (i = 1; i <= 9; i++) {
        if (book[i] == 0) {
            a[step] = i;
            book[i] = 1;
            DFS(step + 1);
            book[i] = 0;
        }
    }
    
    return;
}

int main()
{
    DFS(1);
    
    printf("total = %d\n", total / 2); // 第一个数和第二个数加起来等于第三个数，第1个和第2个数交换位置为一种情况
    return 0;
}