搜索入門之dfs--經典的迷宮問題解析

今天來談一下dfs的入門，以前看到的dfs入門，那真的是入門嗎，都是把dfs的實現步驟往那一貼，看完是知道dfs的步驟了，但是對於代碼實現還是沒有概念。今天准備寫點自己的心得，真的是字面意思--入門。

 

DFS，即深度優先搜索，是一種每次搜索都向盡可能深的地方去搜索，到達盡頭時再回溯進行其他結點去搜索的搜索策略。形象的說，這是一種“不撞南牆不回頭”的策略。

 

其實也就是遍歷，只不過不像一個線性數組的遍歷那么直觀罷了。說到回溯，每次看到這個詞我都得思考一會，到底是怎么用棧進行回溯的呢？今天實際操作了一次bfs，才發現妹的，這個事都是交給編譯器去完成的(只要寫的是遞歸形式)...當然了，非遞歸形式的dfs實現，肯定是要自己做棧的...

 

---

 

迷宮問題

迷宮問題是dfs入門的一個經典問題，這里就以HDOJ 1010 Tempter of Bone 來談談如何實際運用dfs。

http://acm.hdu.edu.cn/showproblem.php?pid=1010

題目大意：　　　　　　　　　　　　　　　　　　　　

　　　　　　　　　　　　　　　　　　　　　　　　　 S.X.

　　　　　　　　　　　　　　　　　　　　　　　　　 ..X.

　　　　　　　　　　　　　　　　　　　　　　　　　 ..XD

　　　　　　　　　　　　　　　　　　　　　　　　　 ....

給出一個由以上四種符號組成的“迷宮”，‘.’代表可以通行的塊，‘X’代表牆不能通過，‘S’代表起點，‘D’代表終點，每秒都必須且只能走一步(上、下、左、右)，判斷能否恰好在第T秒，到達終點D。其中每次走過的‘.’塊都會立刻消失不能再走。

 

當然了，算法就是dfs了，其實也就是暴力枚舉，對走的每一步都進行4個方向上的分支判斷，再加上一定的剪枝，舍去一些明顯不合題意的結果，以滿足時間上的要求。

先貼上代碼吧：

#include<cstdlib>
#include<cstring>
#include<iostream>
using namespace std;
char map[9][9];//輸入的迷宮矩陣
int dir[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};//4個方向
int OK = 0;
int N, M, T, si, sj, di, dj;
int dfs(int si, int sj, int cnt)
{
    if (si <= 0 || sj <= 0 || si > N || sj > M)//超出邊界就說明這條路已經死了，則返回
    {
        return 0;
    }
    if (si == di && sj == dj && cnt == T)//找到終點就返回，把標志位置為1
    {
        OK = 1;
    }
    if (OK)
    {
        return 1;
    }
    int temp = T - cnt - abs(di - si) - abs(dj - sj);//這里就是剪枝，開始沒寫這里，Time Limit Exceeded了十幾次...下面細談
    if (temp < 0 || temp & 1)
    {
        return 0;
    }
    for (int i = 0; i < 4; ++i)//對走到的每個結點都進行四個方向的探索
    {
        if (map[si+dir[i][0]][sj+dir[i][1]] != 'X')
        {
            map[si+dir[i][0]][sj+dir[i][1]] = 'X';//走過的路不能走，就先置為牆
            dfs(si+dir[i][0], sj+dir[i][1], cnt + 1);
            map[si+dir[i][0]][sj+dir[i][1]] = '.';//探索下一條路時，這個結點要恢復成可以走的狀態
        }
    }
    return 0;
}
int main()
{
    while(cin >> N >> M >> T)
    {
        int wall = 0;
        OK = 0;
        if (N == 0 && M == 0 && T == 0)
        {
            break;
        }
        for (int i = 1; i <= N; ++i)
        {
            for (int j = 1; j <= M; ++j)
            {
                cin >> map[i][j];//這里開始還寫的scanf("%c", &map[i][j]);蠢的不談了... 不過可以這樣在for(i)的循環里面寫 scanf("%s", &map[i]); 54                 if (map[i][j] == 'S')
                {
                    si = i;
                    sj = j;
                }else if (map[i][j] == 'D')
                {
                    di = i;
                    dj = j;
                }else if (map[i][j] == 'X')
                {
                    wall++;
                }
            }
        }
        if (N * M - wall <= T)//一個小剪枝
        {
            cout << "NO" << endl;
            continue;
        }
        map[si][sj] = 'X';
        dfs(si, sj, 0);
        if (OK)
        {
            cout << "YES" << endl;
        }else
        {
            cout << "NO" << endl;
        }
    }
    return 0;
}

先借助代碼談一下dfs的過程：

從S開始，i = 0，往右探索，只要沒有return，就一直往右走，return了就回溯，回溯的過程呢，就是從i = 0轉到i = 1了，這就是回溯的實現過程...

 

一個小技巧，初始化這個迷宮矩陣的時候，i = 0 ， j = 0， i = n + 1， j = m + 1都進行初始化，但是不存儲數據，這樣相當於在迷宮外面的四面都加上了牆，這樣在dfs過程中就不用判斷是否出界了...

 

下面談一下剪枝：

1、如果可走的塊數小於T，則肯定不能到達，這就是main()中的那個小剪枝

2、奇偶性剪枝：

可以把map看成這樣：

0 1 0 1 0 1

1 0 1 0 1 0

0 1 0 1 0 1

1 0 1 0 1 0

0 1 0 1 0 1

從為 0 的格子走一步，必然走向為 1 的格子

從為 1 的格子走一步，必然走向為 0 的格子

即：

　　0 ->1或1->0 必然是奇數步

　　0->0 走1->1 必然是偶數步

 

結論：

　　所以當遇到從 0 走向 0 但是要求時間是奇數的，或者， 從 1 走向 0 但是要求時間是偶數的 都可以直接判斷不可達！

這就是dfs中那個剪枝，也就是最主要的剪枝，其中用了&與運算來判斷是不是偶數...

---

 

提醒：

算法中最基本和常用的是搜索，這里要說的是，有些初學者在學習這些搜索基本算法是不太注意剪枝，這是十分不可取的，因為所有搜索的題目給你的測試用例都不會有很大的規模，你往往察覺不出程序運行的時間問題，但是真正的測試數據一定能過濾出那些沒有剪枝的算法。

實際上參賽選手基本上都會使用常用的搜索算法，題目的區分度往往就是建立在諸如剪枝之類的優化上了。 ”