[HDOJ 1180]深度优先搜索 vs. 广度优先搜索

题目:http://acm.hdu.edu.cn/showproblem.php?pid=1180

在做这道题目以前,我一直以为能用BFS写的一定也能用DFS写.由于BFS要额外实现一个队列,并且队列中的元素数目呈指数级增长,远不如DFS的递归来的简洁.所以,遇到搜索题目时我总是尽可能使用DFS.确实,有几道BFS的题目被我用DFS AC了,然而,这道题目我用DFS却无论如何也过不了.

事实上,这道题目确实改变了我对BFS的看法.第一,除了要实现一个队列以外,BFS其实要比DFS更加简洁;第二,如果剪枝做到好,BFS使用的内存空间远比理论中的要小.当然,做好剪枝很难.

下面是我的AC代码,GCC编译器,0ms.但是代码很长,而且必须始终小心谨慎地防止内存泄露,这完全是问题之外的工作.

/* 我喜欢把malloc()放在assert()中 */
#include <assert.h>
/* 我需要INT_MAX来充当无穷大 */
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>

/* 首先,我实现了一个基于数组的简单队列 */

/*
 * 队列
 * 
 * 这是一个基于数组的队列.cell中存放着指向队列元素的指针.
 * void**可以保证这个队列适用于任何元素,它是"万能"的.
 * 
 * 当然,你可以像linux那样,用container_of()宏实现一个基于
 * 双向链表的万能队列.这样做的好处是你不会大量浪费内存,然而,
 * 代价你需要更多的代码和更复杂的逻辑.
 *
 * 队列总是向高地址处增长.first始终指向队列中的第一个元素,
 * last总是指向队列中最后一个元素后面的元素.这样
 *   当first == last时,队列是空的;
 *   当(last + 1) % size == first时,队列是满的.
 */
struct queue {
    void **cell;
    int first, last;
    int size;
};

/*
 * 新建队列
 * 
 * size - 队列大小的估计值,但是你不必担心溢出.
 * 后面有专门的代码来处理溢出,这并不复杂.
 */
struct queue *queue_new(int size)
{
    struct queue *q;


    assert(q = malloc(sizeof(struct queue)));
    assert(q->cell = malloc(sizeof(void *) * size));
    q->size = size;
    q->first = q->last = 0;

    return q;
}

/*
 * 摧毁队列
 * 
 * 注意,队列中的元素不会被销毁.
 * 队列的使用者需要自己把他放进队列中的元素清理干净.
 */
void queue_destroy(struct queue *q)
{
    if (q)
        free(q->cell);
    free(q);
}

/* 重新为队列分配空间 */
void queue_realloc(struct queue *q);

/* 入队 */
void queue_append(void *x, struct queue *q)
{
    if ((q->last + 1) % q->size == q->first)
        queue_realloc(q);
    q->cell[q->last++] = x;
    q->last %= q->size;
}

/*
 * 当队列满的时候,这个函数重新为队列分配空间.
 * 我使用的策略是简单地将队列大小变为当前大小的两倍.
 */
void queue_realloc(struct queue *q)
{
    void **cell;
    int i, size;

    cell = q->cell;

    assert(q->cell = malloc(sizeof(void *) * q->size * 2));
    for (i = 0, size = q->size - 1; i < size; ++i) {
        q->cell[i] = cell[q->first++];
        q->first %= q->size;
    }
    q->first = 0;
    q->last = size;
    q->size <<= 1;

    free(cell);

}

/* 出队 */
void *queue_pop(struct queue *q)
{
    void *ret;

    ret = q->cell[q->first++];
    q->first %= q->size;

    return ret;
}

/*
 * 至此,队列实现完毕.
 * 这个队列与接下来的代码完全是"解耦合"的.
 */

/*
 * 节点
 * 
 * deepth域其实没被使用.但它却被写进了结构体中,
 * 这是我对问题理解不深刻导致的.
 */
struct node {
    int x, y;
    int deepth;
};

/*
 * 为一个新的节点分配内存,并返回这个节点
 */
struct node *node_new(int x, int y)
{
    struct node *n;

    assert(n = malloc(sizeof(struct node)));
    n->x = x;
    n->y = y;

    return n;
}

/*
 * 销毁一个节点.
 * 我们只是简单的调用free()函数
 */
void node_destroy(struct node *n)
{
    free(n);
}

/*
 * 销毁整个队列,包括队列中的元素以及队列本身
 */
void node_queue_destroy(struct queue *q) 
{
    while (q->first != q->last) {
        node_destroy(q->cell[q->first++]);
        q->first %= q->size;
    }
    queue_destroy(q);
}

/* 这是地图的长和宽 */
int height, width;

/* 两张地图,map_0是原始地图;当步长变成奇数的时候,使用map_odd */
char map_0[20][20], map_odd[20][20];

/* 方向,x += dir[d], y += dir[d+5] */
char dir[10] = {0, 1, -1, 0, 0, 0, 0, 0, 1, -1};

/*
 * 通常,我们将visited数组定义成二维的:
 * 
 * int visited[20][20];
 * 
 * 在二维的visited数组中,当节点(x,y)从未被访问过时
 * visited[x][y]的值是无穷大(INT_MAX).
 * 当我们第一次访问它时,它的有了一个肯定比无穷大小的值,
 * 于是我们用这个小的值替换掉无穷大.
 * 当我们再一次经过(x,y)的时候,除非当前的路径长度比visited[x][y]
 * 的值小(这在BFS里面几乎肯定不会发生),否则我们不会更新visited[x][y]
 *
 * 但是,就这道题目而言,有时候我们却不得不需要用一个更大的值
 * 来更新visited[x][y].
 * 
 * 请看这幅地图:
 * S|T
 * 我们第一次经过S时,visited[S]的值是0,但是,
 * 在我们经由S到达T的最终路径上,
 * visited[S]的值却应该是1,因为我们在S上停留了一次.
 *
 * 造成这种局面的原因是,我们的地图是在不断变化的,
 * 地图有两种状态,因此,地图上的每一个节点也随之
 * 获得了两种状态.在同一个节点的不同状态之间比较
 *
 * 因此我给了visited数组第三个纬度,
 * 代表一个节点的两种状态.相应的,
 * 我更新visited数组的策略也从"总是用最小的路径
 * 长度更新节点(x,y)在visited中的值"变成"总是用最小
 * 路径长度更新处于同一状态的(x,y)在visited中的值".
 */
int visited[20][20][2];

/* 广度优先搜索,返回从S到T的最短路径 */
int bfs(int start_x, int start_y)
{
    int deepth = 0;
    /* 这个变量用来处理内存泄漏 */
    struct node *last_c = NULL;

    int x, y, d;
    char (*map)[20], content;

    struct node *n, *c;
    struct queue *q;

    /* 初始化visited数组 */
    for (x = 0; x < height; ++x)
        for (y = 0; y < width; ++y)
            visited[x][y][0] = visited[x][y][1] = INT_MAX;

    n = node_new(start_x, start_y);
    n->deepth = 0;

    /*
     * 我没有计算q的可能大小,而是非常
     * 不负责任地随便给了它一个初始大小:1.
     * 这使得这个队列在一开始的时候就是满的.
     */
    q = queue_new(1);

    /* 插入第一个节点,驱动广度优先搜索 */
    queue_append(n, q);
    visited[start_x][start_y][0] = 0;
/*
 * 每当深度增加地时候,
 * 都会goto到这里来.
 * 按照Dijkstra前辈观点,
 * 我似乎不应该使用goto语句和这个标签,
 * 因为我只要把dive中地语句嵌套进一个循环中就好了.
 * 但是,我觉得那样会使代码更加复杂.
 */
dive:
    /* 根据当前地深度,更新我们所用地地图 */
    map = ((deepth & 1UL) ? map_odd : map_0);
    /* 把NULL排在当前层的尾巴上,作为层结束地标志 */
    queue_append(NULL, q);
    while ((c = (struct node*)queue_pop(q))) {
        /* 小心谨慎地处理内存泄漏 */
        node_destroy(last_c);
        last_c = c;
        /*
         * 由于考虑不周,node地deepth域其实是多余的.
         */
        /* visited[c->x][c->y][deepth & 1UL] = c->deepth; */
        /* 遍历5个方向:上,下,左,右,不动 */
        for (d = 0; d < 5; ++d) {
            x = c->x + dir[d];
            y = c->y + dir[d + 5];
        /* 当我们踩到楼梯上时,
         * 会向前滑一步,这时,
         * 我们必须重新对
         * 当前节点进行合法性以及合理性判断.
         * 与上一个dive标签不同,这个slide
         * 标签我自以为用的挺合理:P
         */
        slide:
            if (x < 0 || x >= height || y < 0 || y >= width)
                continue;
            content = map[x][y];
            if (content == 'T') {
                node_queue_destroy(q);
                node_destroy(c);
                return ++deepth;
            }
            if (content == '*'
                    || (content == '|' && dir[d + 5])
                    || (content == '-' && dir[d]))
                continue;
            /* 踩到楼梯上 */
            if ((content == '|' && dir[d])
                    || content == '-' && dir[d + 5]) {
                x += dir[d];
                y += dir[d + 5];
                goto slide;
            }

            /*
             * 经过了重重检验以后,我终于可以确定自己踩
             * 在了一个合理地位置上.现在,我要检验一下
             * 我地这次来访是不是比我之前地来访更加
             * "优秀",也就是拥有更短的路径长度.
             */
            if (visited[x][y][(deepth + 1) & 1UL] <= deepth + 1)
                continue;
            /* 
             * 我的到来是开拓性的,现在我要
             * 被载入史册了.
             */
            n = node_new(x, y);
            queue_append(n, q);

            /*
             * 我在记得dijkstra算法中,
             * 节点标记的更新是在节点从
             * 队列中取出的时候.因此,
             * 我一开始的时候不假思索地将
             * 这段代码写在了while循环地开头,
             * 结果是永远都不够用地内存. 
             * 
             * 其实,我只记对了一半,
             * 标记地更新的确是在出队地时候,
             * 而距离地更新却是在入队的时候.
             *
             * 这里的关键思想是:无论何时,一旦一个
             * 节点有了更短的路径长度,它就应该
             * 立即被记录下来.记录的时刻越早,
             * 就能阻止越多不知情的相同节点盲目入队.
             */
            visited[x][y][(deepth + 1) & 1UL] = deepth + 1;
        }
    }
    /* 当我们结束了一层以后,就做一些简单处理 */
    if (q->last != q->first) {
        ++deepth;
        goto dive;
    }
}

int main(void)
{
    int x, y, start_x, start_y;

    freopen("Inputs/1180", "r", stdin);
    setbuf(stdout, NULL);

    while (scanf("%d%d%*c", &height, &width) != EOF) {
        for (x = 0; x < height; ++x) {
            for (y = 0; y < width; ++y) {
                scanf("%c", &map_0[x][y]);
                if (map_0[x][y] == 'S') {
                    start_x = x;
                    start_y = y;
                }
            }
            scanf("%*c");
        }

        for (x = 0; x < height; ++x) {
            for (y = 0; y < width; ++y) {
                if (map_0[x][y] == '|')
                    map_odd[x][y] = '-';
                else if(map_0[x][y] == '-')
                    map_odd[x][y] = '|';
                else
                    map_odd[x][y] = map_0[x][y];
            }
        }

        printf("%d\n", bfs(start_x, start_y));

    }

    return 0;
}

为什么在这里BFS要优于DFS?

对于任意一个节点X,它一旦被我们发现,它在当前状态下的最优路径也就同时被我们发现了.这样,在未来的任意时刻,只要我们再次碰到这个节点(相同状态下),我们就可以立即把它过滤(剪枝)掉.这是BFS优于DFS的最关键的地方.在DFS中,我们无论已经经过了同一个节点多少次,我们都不敢扬言说已经找到了到这个节点的最短路径.因此我们可能会在同一个节点上反反复复走很多很多次.

在一个20X20的地图上,基于以下两个事实:1.一个节点最多只有两个状态;2.经过一次的节点绝不会再经过第二次.我们可以知道,我们最多只要遍历800个节点.

这样看来,似乎又是BFS完胜DFS了.事实应该不是这样吧….待我再去刷几道题目先….