深度优先搜索笔记2-机器人路径规划

以下代码改编自《啊哈，算法》，原代码只输出了路径的步数，改编后可以输出所有可行路径与最最短路径。

问题：

已知地图map,给定起点和目标点，要求输出从起点到目标点的所有路径，并计算最短的路径

代码：

/*
已知地图map,给定起点和目标点，要求输出从起点到目标点的所有路径，并计算最短的路径
*/

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

typedef struct Map
{
    int row;
    int col;
    vector<vector<int>> map;
    vector<vector<int>> book;
};

typedef struct Position
{
    int x;
    int y;
};

typedef vector<Position> Route;

void dfs(Map& map, Position& curPos,Position&tarPos,vector<Route>& routes)
{
    static Route route;//存储当前路径使用
    int tx, ty;
    int next[4][2] = { { 0, 1 }, { 1, 0 }, { 0, -1 }, { -1, 0 } };//一个点的上下左右
    if (curPos.x == tarPos.x&&curPos.y == tarPos.y)//判断是否到达目标点
    {
        routes.push_back(route);//将当前路径存储到路径表中
        return;//返回
    }
    for (int i = 0; i < 4; i++)//依次遍历当前点的右边、下边、左边、上边(顺时针方向)
    {
        tx = curPos.x + next[i][0];
        ty = curPos.y + next[i][1];
        if (tx<0 || tx >= map.row ||ty<0 || ty >= map.col)//检查边界条件
        {
            continue;
        }
        //查看此点是否是障碍物以及是否被标记
        if (map.map[tx][ty] == 0 && map.book[tx][ty] == 0)
        {
            map.book[tx][ty] = 1;//标记该点已经走过
            curPos.x = tx;//更新当前点坐标
            curPos.y = ty;
            route.push_back(curPos);//存入路径中
            dfs(map, curPos, tarPos, routes);//以该点为起点进行下一轮的搜索
            map.book[curPos.x][curPos.y] = 0;//取消对该点的标记
            route.pop_back();//弹出该点
            if (route.size() > 0)//判断是否是弹出的最后一个点
            {
                curPos.x = route.back().x;
                curPos.y = route.back().y;
            }
            else//是最后一个点时，将当前点设置为起点
            {
                curPos.x = 0;
                curPos.y = 0;
            }
        }
    }
    return;
}

int main()
{
    Map map;//地图
    Position initPos, tarPos;
    vector<Route> routes;//存储路径

    //定义地图的行和列
    map.row = 5;
    map.col = 4;
    //定义地图
    map.map = { {0,0,1,0},
                {0,0,0,0},
                {0,0,1,0},
                {0,1,0,0},
                {0,0,0,1}};
    //初始化book，用于记录该点是否已经走过
    map.book = {{ 0, 0, 0, 0 },
                { 0, 0, 0, 0 },
                { 0, 0, 0, 0 },
                { 0, 0, 0, 0 },
                { 0, 0, 0, 0 } };
    //起点坐标
    initPos.x = 0;
    initPos.y = 0;
    //终点坐标
    tarPos.x = 4;
    tarPos.y = 2;
    //将起点标记为已经走过
    map.book[initPos.x][initPos.y] = 1;
    //调用深度优先搜索算法计算可能的路径
    dfs(map, initPos, tarPos, routes);

    //输出路径
    int minStep = 99999,index;
    for (int i = 0; i < routes.size(); i++)
    {
        if (minStep>routes[i].size())
        {
            minStep = routes[i].size();
            index = i;
        }
        cout << "Route " << i + 1 << ": ";
        for (int j = 0; j < routes[i].size(); j++)
        {
            cout << "[" << routes[i][j].x << "," << routes[i][j].y << "] ";
        }
        cout << endl;
    }

    cout << "最短路径为：";
    for (int i = 0; i < routes[index].size(); i++)
    {
        cout << "[" << routes[index][i].x << "," << routes[index][i].y << "] ";
    }
    cout << "\n最短路径长度为：" << minStep << endl;

    system("pause");
    return 0;
}

输出结果：

设定起点为(0,0),目标点为(4,2):

参考文献：《啊哈，算法》–啊哈磊