【递归入门】走迷宫

题目描述

有一个nm格的迷宫(表示有n行、m列)，其中有可走的也有不可走的，如果用1表示可以走，0表示不可以走，文件读入这nm个数据和起始点、结束点(起始点和结束点都是用两个数据来描述的，分别表示这个点的行号和列号)。现在要你编程找出所有可行的道路，要求所走的路中没有重复的点，走时只能是上下左右四个方向。如果一条路都不可行，则输出相应信息(用-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的，明显道路不通，对于这种情况要很快地“剪掉”多余分枝得出结论，这就是搜索里所说的“剪枝”。从起点开始往下的一层层的结点，看起来如同树枝一样，对于其中的“枯枝”——明显无用的节点可以先行“剪掉”，从而提高搜索速度。

设计思路

算法分析给出了思路，照着思路来。

首先，需要一个int ans[20][20]数组来存放输入的m行，n列01数字，用以记录哪些点能不能走；

然后，需要一个int temp[20][20] = {0};数组来记录哪些点走没走过，初始化全为0，表示都没走过；

还需要一个存放路线的容器，可以选择vector，每次确定一个点直接用push_back函数就好了，因为里面的点是坐标的形式(x,y)，所以vector的元素可以是一个成员为2个int值的结构体，或者用pair<int,int>作为vector的元素；

再是，确定我们的递归函数DFS(int x, int y)，输入是位置x,y，

先确定递归的结束条件，当(x,y)==终点时递归结束，输出路线，注意，这里DFS的x,y参数此时已经满足条件才会进入到DFS函数中，这个条件就是0<=x<m,0<=y<n且(x,y)这个点为1，之前也没有走过这个点。

再确定递归函数的主体，也就是没有达到递归结束条件时该怎么处理。

temp[x][y] = 1;//更新(x,y)状态，表明已经走过这个点了
for (int i = 0; i < 4; i++)
{
    int tx = x + dis[i][0];
    int ty = y + dis[i][1];
    if (temp[tx][ty] == 0 && ans[tx][ty] == 1 && tx >= 0 && ty >= 0 && tx < m && ty < n)
    {
        temp[tx][ty] = 1;
        vp.push_back(make_pair(tx, ty));
        DFS(tx, ty);
        //等一条路线走完后返回，并删除vector容器队尾的元素
        temp[tx][ty] = 0;
        ans[tx][ty] = 1;
        vp.pop_back();
    }
}

上面基本上就把这道题的思路给弄清楚了，因此整体的代码如下

#include <iostream>
#include <utility>
#include <vector>
using namespace std;

int m, n, flag;
int ans[20][20];        //记录点可不可走
int temp[20][20] = {0}; //记录走没走过
int dis[4][2] = {{0, -1}, {-1, 0}, {0, 1}, {1, 0}};
pair<int, int> Start, End;
vector<pair<int, int>> vp;
//可视化路线
void showVector(vector<pair<int, int>> vp)
{
    for (int i = 0; i < vp.size(); i++)
    {
        cout << "(" << vp[i].first + 1 << "," << vp[i].second + 1 << ")";
        if (i == vp.size() - 1)
            cout << "\n";
        else
            cout << "->";
    }
}
//递归
void DFS(int x, int y)
{
    //如果到达终点，则输出路线
    if (x == End.first - 1 && y == End.second - 1)
    {
        flag = 1;
        showVector(vp);
        return;
    }
    temp[x][y] = 1;
    for (int i = 0; i < 4; i++)
    {
        int tx = x + dis[i][0];
        int ty = y + dis[i][1];
        if (temp[tx][ty] == 0 && ans[tx][ty] == 1 && tx >= 0 && ty >= 0 && tx < m && ty < n)
        {
            temp[tx][ty] = 1;
            vp.push_back(make_pair(tx, ty));
            DFS(tx, ty);
            //等一条路线走完后返回，并删除vector容器队尾的元素
            temp[tx][ty] = 0;
            ans[tx][ty] = 1;
            vp.pop_back();
        }
    }
}

int main()
{
    while (cin >> m >> n)
    {
        flag = 0;//标记，如果一条路都没有的话为0
        vp.clear();
        for (int i = 0; i < m; i++)
        {
            for (int j = 0; j < n; j++)
            {
                cin >> ans[i][j];
            }
        }

        cin >> Start.first >> Start.second;
        cin >> End.first >> End.second;

        //递归
        vp.push_back(make_pair(Start.first - 1, Start.second - 1));
        DFS(Start.first - 1, Start.second - 1);

        if (flag == 0)
            cout << -1 << endl;
    }
    return 0;
}

但是，我并没有对这个思路做剪枝处理，剪枝处理比较简单，就是在main函数里进行递归之前，先查一查起点到终点这个矩阵里面有没有全为0的行或者列，求一个列和和行和，判断是否为0就行。
还有一点就是，程序返回-1还有一种情况就是找不到路线，并不仅仅是存在全为0的行或列，程序设置flag的目的就是为了解决这个问题。