dfs深度优先搜索探究迷宫的最短路径(C++)

本文详细介绍了如何使用C++编程实现寻找6x6迷宫的最短路径算法,包括深度优先搜索(DFS)策略和路径保存。通过二维数组表示迷宫,并利用pair保存坐标,最终找到并输出最短路径及其长度。代码中还提供了针对不同方向的递归探索以及如何判断和更新最短路径长度。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

以下有个 6*6 的迷宫

6 6
0 1 0 0 1 0
0 0 0 0 0 1
1 0 1 1 0 0
0 0 0 1 0 0
0 1 0 0 0 1
0 0 0 1 0 0

根据上图寻找的最短路径如下:

按照红色路径走时的坐标如下

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

按照蓝色路径走时的坐标如下

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

设计一个这样子的算法,保存的是探索过程所通过并且最后成功到达右下角出口的路线的每一个点的坐标,需要用到C++这样的函数

make_pair(x,y);

pair(x,y);

作为保存探索过程成对坐标的关键。

保存这样的成对的坐标的数组如下:

vector<pair<int,int>> oop;                               //保存的是一条完整的成功的路径的数组

vector<vector<pair<int,int>>> temp;                //保存的是所有成功的路径的数组

其中temp数组是个二维数组,行作为一条路径,该行的列保存该路径的所有的点的坐标,那么判断路径是否为最短,只需要遍历每行判断找出最短。

在每条路径的探索当中,需要对路线进行已访问的设置,如下数组:

vector<vector<bool>> visit;

分下 -> 上 -> 右 -> 左   递归进行探索(可换)

    dfs(min_way,a,i+1,j,visit,n,m,oop,temp);        //分下 -> 上 -> 右 -> 左 四个方向查找
    dfs(min_way,a,i-1,j,visit,n,m,oop,temp);
    dfs(min_way,a,i,j+1,visit,n,m,oop,temp);
    dfs(min_way,a,i,j-1,visit,n,m,oop,temp);

输出路径版的代码如下:

  1. //迷宫的最短路径问题
  2. #include<iostream>
  3. #include<vector>
  4. using namespace std;
  5. //注意此处的oop应该每次递归进入的空间的都是不同的,同时visit也是一样的,不能各个空间公用,应当独立
  6. //所以每个递归空间的寻路的路径长度都是单独的,所以不能用&oop,容易造成数据错误
  7. void dfs(int & min_way,int a[][10],int i,int j,vector<vector<bool>> visit,int n,int m,vector<pair<int,int>> oop,vector<vector<pair<int,int>>> & temp)
  8. {
  9. if(i<0 || i>=n || j<0 || j>=m || visit[i][j] || a[i][j]==1)
  10. {
  11. return;
  12. }
  13. if(!visit[i][j])
  14. {
  15. oop.push_back(make_pair(i,j));
  16. }
  17. visit[i][j] = true;
  18. if(i == n-1 && j == m-1)
  19. {
  20. temp.push_back(oop);
  21. if(oop.size() < min_way)
  22. {
  23. min_way = oop.size();
  24. }
  25. return;
  26. }
  27. dfs(min_way,a,i+1,j,visit,n,m,oop,temp); //分下 -> 上 -> 右 -> 左 四个方向查找
  28. dfs(min_way,a,i-1,j,visit,n,m,oop,temp);
  29. dfs(min_way,a,i,j+1,visit,n,m,oop,temp);
  30. dfs(min_way,a,i,j-1,visit,n,m,oop,temp);
  31. }
  32. int main(void)
  33. {
  34. int n,m;
  35. cin >> n >> m;
  36. int a[10][10];
  37. vector<vector<bool>> visit;
  38. vector<pair<int,int>> oop;
  39. visit.resize(n,vector<bool>(m,false));
  40. vector<vector<pair<int,int>>> temp;
  41. for(int i=0;i<n;i++)
  42. {
  43. for(int j=0;j<m;j++)
  44. {
  45. cin >> a[i][j];
  46. }
  47. }
  48. int min_way=101; //注意此处的oop应该每次递归进入的空间的都是不同的,
  49. dfs(min_way,a,0,0,visit,n,m,oop,temp);
  50. //所以每个递归空间的寻路的路径长度都是单独的,所以不能用&oop,容易造成数据错误
  51. for(int i=0;i<temp.size();i++)
  52. {
  53. if(min_way == temp[i].size())
  54. {
  55. for(int j=0;j<temp[i].size();j++)
  56. {
  57. cout << temp[i][j].first << " " << temp[i][j].second << endl;
  58. }
  59. }
  60. cout << "-----" << endl;
  61. }
  62. return 0;
  63. }
  64. /*
  65. *
  66. 6 6
  67. 0 1 0 0 1 0
  68. 0 0 0 0 0 1
  69. 1 0 1 1 0 0
  70. 0 0 0 1 0 0
  71. 0 1 0 0 0 1
  72. 0 0 0 1 0 0
  73. 5 6
  74. 0 1 0 0 1 0
  75. 0 0 0 0 0 1
  76. 1 0 1 1 0 0
  77. 0 0 0 1 0 0
  78. 0 1 0 0 0 0
  79. */

输出情况如下:

当只需要单纯的输出最短路径的大小时:

只需要把源代码稍作修改,将temp如掉,每次oop.size()与min_way进行比较替换即可。

if(i == n-1 && j == m-1)
    {
        if(oop.size() < min_way)
        {
            min_way = oop.size();
        }
        return;
    }

 迷宫最短路径纯输出最短路径长度的完整代码如下:

  1. //迷宫最短路径问题,纯输出路径版
  2. #include<iostream>
  3. #include<vector>
  4. using namespace std;
  5. //注意此处的oop应该每次递归进入的空间的都是不同的,同时visit也是一样的,不能各个空间公用,应当独立
  6. //所以每个递归空间的寻路的路径长度都是单独的,所以不能用&oop,容易造成数据错误
  7. void dfs(int & min_way,int a[][10],int i,int j,vector<vector<bool>> visit,int n,int m,vector<pair<int,int>> oop)
  8. {
  9. if(i<0 || i>=n || j<0 || j>=m || visit[i][j] || a[i][j]==1)
  10. {
  11. return;
  12. }
  13. if(!visit[i][j])
  14. {
  15. oop.push_back(make_pair(i,j));
  16. }
  17. visit[i][j] = true;
  18. if(i == n-1 && j == m-1)
  19. {
  20. if(oop.size() < min_way)
  21. {
  22. min_way = oop.size();
  23. }
  24. return;
  25. }
  26. dfs(min_way,a,i+1,j,visit,n,m,oop);
  27. dfs(min_way,a,i-1,j,visit,n,m,oop);
  28. dfs(min_way,a,i,j+1,visit,n,m,oop);
  29. dfs(min_way,a,i,j-1,visit,n,m,oop);
  30. }
  31. int main(void)
  32. {
  33. int n,m;
  34. cin >> n >> m;
  35. int a[10][10];
  36. vector<vector<bool>> visit;
  37. vector<pair<int,int>> oop;
  38. visit.resize(n,vector<bool>(m,false));
  39. // vector<vector<pair<int,int>>> temp;
  40. for(int i=0;i<n;i++)
  41. {
  42. for(int j=0;j<m;j++)
  43. {
  44. cin >> a[i][j];
  45. }
  46. }
  47. int min_way=101; //注意此处的oop应该每次递归进入的空间的都是不同的,
  48. dfs(min_way,a,0,0,visit,n,m,oop);
  49. //所以每个递归空间的寻路的路径长度都是单独的,所以不能用&oop,容易造成数据错误
  50. cout << min_way << endl;
  51. return 0;
  52. }

运行结果如下:

 

评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值

举报

选择你想要举报的内容(必选)
  • 内容涉黄
  • 政治相关
  • 内容抄袭
  • 涉嫌广告
  • 内容侵权
  • 侮辱谩骂
  • 样式问题
  • 其他
点击体验
DeepSeekR1满血版
程序员都在用的中文IT技术交流社区

程序员都在用的中文IT技术交流社区

专业的中文 IT 技术社区,与千万技术人共成长

专业的中文 IT 技术社区,与千万技术人共成长

关注【CSDN】视频号,行业资讯、技术分享精彩不断,直播好礼送不停!

关注【CSDN】视频号,行业资讯、技术分享精彩不断,直播好礼送不停!

客服 返回顶部