2014省赛大总结（一） DFS 与 BFS

第一部分：DFS

        DFS（深度优先搜索），深度优先搜索法与回溯法差不多，主要的区别是回溯法在求解过程中不保留完整的树结构，而深度优先搜索则记下完整的搜索树，搜索树起记录解路径和状态判重的作用。为了减少存储空间，在深度优先搜索中，用标志的方法记录访问过的状态，这种处理方法使得深度优先搜索法与回溯法没什么区别了。

        深度优先搜索所遵循的搜索策略是尽可能“深”地搜索图。在深度优先搜索中，对于最新发现的结点，如果它还有以此为起点而未搜过的边，就沿着边继续搜索下去。当结点v的所有边都已被探寻过，搜索将回溯到发现结点v有那条边的始结点。这一过程一直进行到已发现从源结点可达的所有结点为止。如果还存在未被发现的结点，则选择其中一个作为源结点并重复以上过程，整个过程反复进行直到所有结点都被发现为止。

        代表题目：N皇后问题 

#include<stdio.h>   #define N 15     int n; //皇后个数   int sum = 0; //可行解个数   int x[N]; //皇后放置的列数       int place(int k)   {       int i;       for(i=1;i<k;i++)         if(abs(k-i)==abs(x[k]-x[i]) || x[k] == x[i])           return 0;       return 1;   }       int queen(int t)   {       if(t>n && n>0) //当放置的皇后超过n时，可行解个数加1，此时n必须大于0         sum++;       else        for(int i=1;i<=n;i++)         {             x[t] = i; //标明第t个皇后放在第i列             if(place(t)) //如果可以放在某一位置，则继续放下一皇后               queen(t+1);          }       return sum;   }     int main()   {       int t;       scanf("%d",&n);       t = queen(1);       if(n == 0) //如果n=0，则可行解个数为0，这种情况一定不要忽略         t = 0;       printf("%d",t);       return 0;   }  

      

        DFS的限制在于溢出危险，因为DFS的递归实现复杂度在 O(n^2)以上 （实例代码的复杂度为 O(n^3 *1/ 3)），在N比较多的情况下，时间和空间的开销都是巨大的，所以在使用过程中要注意剪枝操作的灵活运用。

第二部分：BFS

        BFS（宽度优先遍历，又称广度优先搜索算法）的核心思想是：从初始结点开始，应用算符生成第一层结点，检查目标结点是否在这些后继结点中，若没有，再用产生式规则将所有第一层的结点逐一扩展，得到第二层结点，并逐一检查第二层结点中是否包含目标结点。若没有，再用算符逐一扩展第二层所有结点……，如此依次扩展，直到发现目标结点为止。

       代表题目：HDU 1072 Nightmare

       题目大意：在迷宫中有一个炸弹，过六个单位时间就会爆炸，要你求一个起点到迷宫的终点的最短距离，迷宫中有时间重置器，当你走到这个格子，炸弹的爆炸时间重新置为0，迷宫中标识为墙壁的格子不能走，到达任意一个格子时，炸弹计数器为0时，则失败。

       解题思路:最短距离，就想到用宽度优先遍历，但是要一个辅助的数组来保存每个格子的时间信息。之前受hdu 1242的影响，认为格子保存的是当前走过路程的最小值，w了很多次。。。。以为每个格子前进一步的花费时间单位是一样的，所以宽度遍历的结果自然是最短距离，由于时间单位有限制，只能走六个单元，只有在这六个时间单位里到达了终点，或者走到了时间设置开关把炸弹计时器置为0才能继续走下去，所以要一个辅助数组来保存每个格子剩余的最大时间单位，只有走到当前的格子的剩余时间单位比之前的大时，这个状态才能加入队列中。

       

#include <iostream>#include <cstdio>#include <cstring>#include <cstdlib>#include <queue>#include <algorithm>using namespace std;struct node{    int x, y;    int step;    int t;};const int maxn = 9;int dir[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};int maze[maxn][maxn], graph[maxn][maxn];int n, m, ex, ey, ans;bool bfs(int x, int y);int main(){        int test;    scanf("%d", &test);    while(test-- != 0)    {        scanf("%d %d", &n, &m);        int sx, sy;        for(int i = 0; i < n; i++)        {            for(int j = 0; j < m; j++)            {                scanf("%d", &maze[i][j]);                if(maze[i][j] == 2)                    sx = i, sy = j;                if(maze[i][j] == 3)                    ex = i, ey = j;                graph[i][j] = 0;            }        }        if(bfs(sx, sy))            printf("%d\n", ans);        else            printf("-1\n");    }        return 0;}bool bfs(int x, int y){    queue<node> que;    node s;    s.x = x;    s.y = y;    s.step = 0;    s.t = 6;    graph[x][y] = 6;    que.push(s);    while(!que.empty())    {        node st = que.front();        que.pop();        if(st.x == ex && st.y == ey)        {            ans = st.step;            return true;        }        if(st.t == 1)            continue;        for(int i = 0; i < 4; i++)        {            int dx = st.x + dir[i][0];            int dy = st.y + dir[i][1];            if(dx >= 0 && dx < n && dy >= 0 && dy < m && maze[dx][dy] != 0)            {                node tmp;                tmp.x = dx; tmp.y = dy;                tmp.step = st.step + 1;                tmp.t  = st.t - 1;                if(maze[dx][dy] == 4)                    tmp.t = 6;                if(tmp.t > graph[dx][dy])                {                    graph[dx][dy] = tmp.t;                    que.push(tmp);                }            }        }    }    return false;}

        宽度优先搜索是最简单的图的搜索算法之一，这一算法也是很多重要的图的算法的原型。Dijksta单源最短路径算法和Prim最小生成树算法都采用了与宽度优先搜索类似的思想。

        BFS的空间限制性比DFS少了很多，溢出的隐患几乎不存在，但是时间复杂度依然不小。BFS的判断重复如果直接判断十分耗时，一般可以借助哈希表来优化，这里不再赘述。

这两种搜索在平时的运用非常广泛，我们应该做到对这两种的运作方式烂熟于胸，这对以图论的学习十分有帮助。