【DFS/递归】问题 F: 【递归入门】走迷宫

题目描述

　　有一个n*m格的迷宫(表示有n行、m列)，其中有可走的也有不可走的，如果用1表示可以走，0表示不可以走，文件读入这n*m个数据和起始点、结束点(起始点和结束点都是用两个数据来描述的，分别表示这个点的行号和列号)。现在要你编程找出所有可行的道路，要求所走的路中没有重复的点，走时只能是上下左右四个方向。如果一条路都不可行，则输出相应信息(用-l表示无路)。

　　请统一用 左上右下的顺序拓展，也就是 (0,-1),(-1,0),(0,1),(1,0)

输入

第一行是两个数n，m( 1 < n ， m < 15 )，接下来是m行n列由1和0组成的数据，最后两行是起始点和结束点。

输出

　　所有可行的路径，描述一个点时用(x，y)的形式，除开始点外，其他的都要用“->”表示方向。

　　如果没有一条可行的路则输出-1。

样例输入 复制

5 6
1 0 0 1 0 1
1 1 1 1 1 1
0 0 1 1 1 0
1 1 1 1 1 0
1 1 1 0 1 1
1 1
5 6

样例输出 复制

(1,1)->(2,1)->(2,2)->(2,3)->(2,4)->(2,5)->(3,5)->(3,4)->(3,3)->(4,3)->(4,4)->(4,5)->(5,5)->(5,6)
(1,1)->(2,1)->(2,2)->(2,3)->(2,4)->(2,5)->(3,5)->(3,4)->(4,4)->(4,5)->(5,5)->(5,6)
(1,1)->(2,1)->(2,2)->(2,3)->(2,4)->(2,5)->(3,5)->(4,5)->(5,5)->(5,6)
(1,1)->(2,1)->(2,2)->(2,3)->(2,4)->(3,4)->(3,3)->(4,3)->(4,4)->(4,5)->(5,5)->(5,6)
(1,1)->(2,1)->(2,2)->(2,3)->(2,4)->(3,4)->(3,5)->(4,5)->(5,5)->(5,6)
(1,1)->(2,1)->(2,2)->(2,3)->(2,4)->(3,4)->(4,4)->(4,5)->(5,5)->(5,6)
(1,1)->(2,1)->(2,2)->(2,3)->(3,3)->(3,4)->(2,4)->(2,5)->(3,5)->(4,5)->(5,5)->(5,6)
(1,1)->(2,1)->(2,2)->(2,3)->(3,3)->(3,4)->(3,5)->(4,5)->(5,5)->(5,6)
(1,1)->(2,1)->(2,2)->(2,3)->(3,3)->(3,4)->(4,4)->(4,5)->(5,5)->(5,6)
(1,1)->(2,1)->(2,2)->(2,3)->(3,3)->(4,3)->(4,4)->(3,4)->(2,4)->(2,5)->(3,5)->(4,5)->(5,5)->(5,6)
(1,1)->(2,1)->(2,2)->(2,3)->(3,3)->(4,3)->(4,4)->(3,4)->(3,5)->(4,5)->(5,5)->(5,6)
(1,1)->(2,1)->(2,2)->(2,3)->(3,3)->(4,3)->(4,4)->(4,5)->(5,5)->(5,6)

提示

【算法分析】

　　用一个a数组来存放迷宫可走的情况，另外用一个数组b来存放哪些点走过了。每个点用两个数字来描述，一个表示行号，另一个表示列号。对于某一个点(x，y)，四个可能走的方向的点描述如下表：

　　　2

1　　x,y　　3

　　　4

　　对应的位置为：(x, y-1)，(x-1, y)，(x, y+1)，(x+1, y)。所以每个点都要试探四个方向，如果没有走过(数组b相应的点的值为0)且可以走(数组a相应点的值为1)同时不越界，就走过去，再看有没有到达终点，到了终点则输出所走的路，否则继续走下去。

　　这个查找过程用search来描述如下：

procedure search(x, y, b, p)；{x，y表示某一个点，b是已经过的点的情况，p是已走过的路}

　begin

　　　for i:＝1 to 4 do{分别对4个点进行试探}

　　　begin

　　　　　先记住当前点的位置，已走过的情况和走过的路；

　　　　　如果第i个点(xl，y1)可以走，则走过去；

　　　　　如果已达终点，则输出所走的路径并置有路可走的信息，

　　　　　否则继续从新的点往下查找search(xl，y1，b1，p1)；

　　　end；

　end；

　　有些情况很明显是无解的，如从起点到终点的矩形中有一行或一列都是为0的，明显道路不通，对于这种情况要很快地“剪掉”多余分枝得出结论，这就是搜索里所说的“剪枝”。从起点开始往下的一层层的结点，看起来如同树枝一样，对于其中的“枯枝”——明显无用的节点可以先行“剪掉”，从而提高搜索速度。

分析：

利用DFS的思想，把每次选择左上右下四个方向前进作为“岔道口”，把到达终点、遇到不可走或是走过的点作为“死胡同”。同样地，可以把这些“死胡同”利用剪枝的形式放在选择“岔道口”的过程中。

#include <iostream>
#include <vector>

using namespace std;

int n, m, cnt;
int bei, bej, eni, enj;
int I[4] = {0, -1, 0, 1}, J[4] = {-1, 0, 1, 0};
struct node{
    bool flag = false;
    int fe = 0;
};
struct noder{
    int i, j;
    noder(int i_, int j_){
        i = i_;
        j = j_;
    };
};

bool JudgeM(int i, int j){
    if(i >= 1 && i <= n && j >= 1 && j <= m) return true;
    else return false;
}
void DFS(vector<noder> s, node N[16][16], int nowi, int nowj){
    if(nowi == eni && nowj == enj){
        noder r = noder(nowi, nowj);
        s.push_back(r);

        for(int i = 0; i < s.size(); i++){
            cout << '(' << s[i].i << ',' << s[i].j << ')';
            if(i != s.size() - 1){
                cout << "->";
            }else{
                cout << '\n';
            }
        }
        cnt++;
        return;
    }
    if(!JudgeM(nowi, nowj) || N[nowi][nowj].fe == 0) return;

    noder r = noder(nowi, nowj);
    s.push_back(r);

    for(int i = 0; i < 4; i++){
        int newi = nowi + I[i];
        int newj = nowj + J[i];
        if(N[newi][newj].flag == false){
            N[newi][newj].flag = true;
            DFS(s, N, newi, newj);
            N[newi][newj].flag = false;
        }
    }
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);

    while(cin >> n >> m){
        node N[16][16];
        for(int i = 1; i <= n; i++){
            for(int j = 1; j <= m; j++){
                cin >> N[i][j].fe;
            }
        }
        cin >> bei >> bej >> eni >> enj;

        vector<noder> s;
        N[bei][bej].flag = true;
        cnt = 0;
        DFS(s, N, bei, bej);
        if(!cnt){
            cout << "-1\n";
        }
    }
    return 0;
}