DFS,BFS打印可走路径

最新推荐文章于 2023-01-07 20:22:50 发布
最新推荐文章于 2023-01-07 20:22:50 发布
阅读量254 收藏 2
点赞数 1
分类专栏： # 图论 算法笔记 文章标签： 算法 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51825761/article/details/125714356
版权

 

/**
      problem: 给定一个n×m的迷宫矩阵，其中'*'代表墙壁，不可通过；而'.'代表平地，可以通过；
      S代表起点，T代表终点。移动过程中，当前位置为（x，y），且每次只能向上下左右
      （x，y+1），（x，y-1），（x+1，y），（x-1，y）的平地移动，求S到T的最短步数。

     其中迷宫矩阵如下S(2,4)  T(4,3)：
     data:
         5 5
        .....
        .*.*.
        .*.*.
        .***.
        ....*
        2 2 4 3
*/

/**
    solution 1:BFS求出最短步数；
*/

/**
      problem: 给定一个n×m的迷宫矩阵，其中'*'代表墙壁，不可通过；而'.'代表平地，可以通过；
      S代表起点，T代表终点。移动过程中，当前位置为（x，y），且每次只能向上下左右
      （x，y+1），（x，y-1），（x+1，y），（x-1，y）的平地移动，求S到T的最短步数。

     其中迷宫矩阵如下S(2,4)  T(4,3)：
     data:
         5 5
        .....
        .*.*.
        .*.*.
        .***.
        ....*
        2 2 4 3
*/

/**
    solution 1:BFS求出最短步数；
*/

#include <iostream>
#include <cstdio>
#include <queue>
using namespace std;
struct Node
{
    int x,y;
    int step;
};
const int maxn=20;
char maze[maxn][maxn];
int inq[maxn][maxn]={0};
int m,n;
int X[4]={0,0,1,-1};
int Y[4]={1,-1,0,0};
bool judge(int x,int y);
int BFS(Node a,Node b);
int main()
{
    printf("输入的迷宫行数与列数:\n");
    scanf("%d%d",&n,&m);
    printf("输入%d行%d列元素:\n",n,m);
    for(int i=0;i<n;i++)
            scanf("%s",maze[i]);
    Node origin,end;
    printf("输入起点坐标，终点坐标:\n");
    scanf("%d%d%d%d",&origin.x,&origin.y,&end.x,&end.y);
    origin.step=0;
    int ans=BFS(origin,end);
    cout << ans <<endl;
    return 0;
}

bool judge(int x,int y)
{
    if(x>=n||x<0||y>=m||y<0)
        return 0;
    if(maze[x][y]=='*'||inq[x][y]==1)
        return 0;
    return 1;
}

int BFS(Node a,Node b)
{
    Node node;
    queue<Node> q;
    q.push(a);
    inq [a.x][a.y]=1;
    while(!q.empty())
    {
        Node top=q.front();
        q.pop();
        if(top.x==b.x&&top.y==b.y)
            return top.step;
        for(int i=0;i<4;i++)
        {
            int newx=top.x+X[i];
            int newy=top.y+Y[i];
            if(judge(newx,newy))
            {
                node.x=newx;
                node.y=newy;
                node.step=top.step+1;
                q.push(node);
                inq[newx][newy]=1;
            }
        }
    }
    return -1;
}

 

2)BFS找出一条通向终点的路，并打印输出。
 * \ 每次记录入队结点的前驱节点，最后到达终点时，可以逆序打印，也可以再用一个矩阵
     来存储入口到出口的路径；

/** \brief
 *
 * \ 2)BFS找出一条通向终点的路，并打印输出。
 * \ 每次记录入队结点的前驱节点，最后到达终点时，可以逆序打印，也可以再用一个矩阵
     来存储入口到出口的路径；
 *  data:
        5 6
        ......
        .*.*.*
        .*S*..
        ..**..
        ...T.*
        2 2 4 3
 */

#include <iostream>
#include <cstdio>
#include <queue>
using namespace std;
struct Node
{
    int x,y;
    int step,pre;   //step为该结点走的步数，pre为上一个结点的下标
    Node(int _x,int _y) : x(_x),y(_y) {}
    Node(){}
} road[100]; //road并不是存储所有的结点，只存储入队的节点；
int qh=-1,qe=1; //qh为road的头结点，qe为roadde尾结点
const int maxn=20;
int hash_table[maxn][maxn]={0}; //记录一条正确道路的值，以便输出
char maze[maxn][maxn];  //输入的地图矩阵
int inq[maxn][maxn]={0};    //判断节点是否入队
int m,n;    //m行n列地图
int X[4]={0,0,1,-1};    //方向数组
int Y[4]={1,-1,0,0};
bool judge(int x,int y);    //该节点是否合法，能否通过
void BFS(Node a,Node b);
void out(); //输出一条正确的道路
int main()
{
    printf("输入的迷宫行数与列数:\n");
    scanf("%d%d",&n,&m);
    printf("输入%d行%d列元素:\n",n,m);
    for(int i=0;i<n;i++)
            scanf("%s",maze[i]);
    Node origin,end;
    printf("输入起点坐标，终点坐标:\n");
    scanf("%d%d%d%d",&origin.x,&origin.y,&end.x,&end.y);
    origin.step=0;
    BFS(origin,end);
    return 0;
}

bool judge(int x,int y)
{
    if(x>=n||x<0||y>=m||y<0)
        return 0;
    if(maze[x][y]=='*'||inq[x][y]==1)
        return 0;
    return 1;
}

void BFS(Node a,Node b)
{
    Node node;
    queue<Node> q;
    a.pre=qh;
    road[0]=a;
    q.push(a);
    inq [a.x][a.y]=1;
    while(!q.empty())
    {
        ++qh;
        Node top=q.front();
        q.pop();
        if(top.x==b.x&&top.y==b.y)
        {
            cout << "total steps: " << top.step << endl;
            out();
            return;
        }
        for(int i=0;i<4;i++)
        {
            int newx=top.x+X[i];
            int newy=top.y+Y[i];
            if(judge(newx,newy))
            {
                node=Node(newx,newy);
                node.step=top.step+1;
                node.pre=qh;
                road[qe++]=node;
                q.push(node);
                inq[newx][newy]=1;
            }
        }
    }
    cout << "impossible\n";
}

void out()
{
    int temp=qh;
    cout << "逆序输出迷宫的正确出口道路:\n";
    while(1)
    {
        hash_table[road[temp].x][road[temp].y]=1;
        cout << road[temp].x << ' '  << road[temp].y << endl;
        if(road[temp].pre==-1)
            break;
        temp=road[temp].pre;
    }
    cout << "正确道路的地图:\n";
    for(int  i=0;i<n;++i)
    {
        for(int j=0;j<m;++j)
            if(hash_table[i][j]==1)
                cout << "#";
            else
                cout << "$";
        cout << endl;
    }
}

/*  ***** DFS  ***** */
/*  用回溯打印出所有可以通过的结果  */

/*  ***** DFS  ***** */
/*  用回溯打印出所有可以通过的结果  */

#include <iostream>
#include <cstdio>
using namespace std;
struct Node
{
    int x,y;
    int step;
    Node(int newx,int newy):x(newx),y(newy){}
    Node()=default;
};
const int maxn=20;
char maze[maxn][maxn];
int vis[maxn][maxn]={0};
int m,n;
int X[4]={0,0,1,-1};
int Y[4]={1,-1,0,0};
bool judge(int x,int y);
int DFS(Node a,Node b,int depth);
void out();
int main()
{
    printf("输入的迷宫行数与列数:\n");
    scanf("%d%d",&n,&m);
    printf("输入%d行%d列元素:\n",n,m);
    for(int i=0;i<n;i++)
        scanf("%s",maze[i]);
    Node origin,end;
    printf("输入起点坐标，终点坐标:\n");
    scanf("%d%d%d%d",&origin.x,&origin.y,&end.x,&end.y);
    int sum=0;
    for(int i=0;i<n;++i)
        for(int j=0;j<m;++j)
        {
            if(maze[i][j]=='.')
                ++sum;
        }
    cout << sum << endl;
    origin.step=0;
    maze[origin.x][origin.y]='y';
    DFS(origin,end,0);
    cout << "\n以下为调试代码\n";
    for(int i=0;i<n;++i)
    {
        for(int j=0;j<m;++j)
        {
            cout << maze[i][j] << ' ';
        }
        cout << endl;
    }

    int total=0;
    for(int i=0;i<n;++i)
        for(int j=0;j<m;++j)
        {
            if(maze[i][j]=='y')
                ++total;
        }
    cout << total << endl;
    return 0;
}


int DFS(Node a,Node b,int depth)
{
    int newx,newy;
    for(int i=0;i<4;++i)
    {
        newx=a.x+X[i];
        newy=a.y+Y[i];
        if(judge(newx,newy))
        {
            char ch=maze[newx][newy];
            maze[newx][newy]='y';
            Node temp(newx,newy);
            if(newx==b.x&&newy==b.y)
            {
                cout << "succend\n";
                out();
            }
            else
                DFS(temp,b,depth+1);
            maze[newx][newy]=ch;
        }
    }
    maze[a.x][a.y]='n';
}

void out()
{
    int total=0;
    for(int i=0;i<n;++i)
    {
        for(int j=0;j<m;++j)
        {
            if(maze[i][j]=='y')
            {
                cout << 'V';
                ++total;
            }
            else
                cout << '*';
        }
        cout << endl;
    }
    cout << total-1 << endl;
}

bool judge(int x,int y)
{
    if(x>=m||x<0||y>=n||y<0)
        return 0;
    if(maze[x][y]=='T')
        return 1;
    if(maze[x][y]!='.')
        return 0;
    return 1;
}


/*
5 6
......
.*.*.*
.*S*..
..**..
...T.*
2 2 4 3
*/

疯疯癫癫才自由
关注
专栏目录
深度与广度-图的遍历算法DFS与BFS的对比与应用
一键难忘的博客
09-13 2143
通过以上实际应用案例和代码示例，我们可以更直观地理解DFS和BFS在不同场景中的具体应用和效果。DFS：适用于需要深度探索的场景，如路径搜索、连通性检测、拓扑排序和环检测。在这些应用中，DFS可以充分利用其递归性质，提供简洁有效的解决方案。BFS：适用于需要广度优先的场景，如最短路径搜索、层次遍历和双向搜索。在这些应用中，BFS能够逐层扩展，确保较早找到目标，提供高效的搜索过程。选择合适的算法对于解决实际问题至关重要。
DFS+打印路径+最小字典序
Sti1lWater的博客
03-17 239
DFS
22.3.12走迷宫（dfs，打印路径）
m0_63925226的博客
03-12 577
题目描述   有一个n*m格的迷宫(表示有n行、m列)，其中有可走的也有不可走的，如果用1表示可以走，0表示不可以走，文件读入这n*m个数据和起始点、结束点(起始点和结束点都是用两个数据来描述的，分别表示这个点的行号和列号)。现在要你编程找出所有可行的道路，要求所走的路中没有重复的点，走时只能是上下左右四个方向。如果一条路都不可行，则输出相应信息(用-l表示无路)。   请统一用 左上右下的顺序拓展，也就是 (0,-1),(-1,0),(0,1),(1,0) 输入 第一行是两个数n，m( 1 <
九度OJ 1090：路径打印 （树、DFS）
weixin_30361641的博客
10-22 155
时间限制：1 秒 内存限制：32 兆 特殊判题：否 提交：1704 解决：314 题目描述： 给你一串路径，譬如： a\b\c a\d\e b\cst d\ 你把这些路径中蕴含的目录结构给画出来，子目录直接列在父目录下面，并比父目录向右缩一格，就像这样： a b c d e b ...
完全二叉树dfs打印路径--1155 Heap Paths (30 分)
ur_ytii的博客
02-21 127
1155 Heap Paths (30 分) In computer science, a heap is a specialized tree-based data structure that satisfies the heap property: if P is a parent node of C, then the key (the value) of P is either greater than or equal to (in a max heap) or less than or eq
路径打印（建树，DFS）
sunshine_lyn的博客
03-17 604
题目描述给你一串路径，譬如： a\b\c a\d\e b\cst d\ 你把这些路径中蕴含的目录结构给画出来，子目录直接列在父目录下面，并比父目录向右缩一格，就像这样： a   b     c   d      e b   cst d 同一级的需要按字母顺序排列，不能乱。输入描述:    每个测试案例第一行为一个正整数n（n&lt;=10）表示有n个路径，当n为0时，测试结束，接下来有n行，每行有...
C语言：图的DFS和BFS（内附代码和算法思路）.docx
11-01
总的来说，理解和实现DFS与BFS对于理解图的遍历至关重要，它们在解决许多实际问题，如寻找最短路径、判断连通性等场景中都有着广泛的应用。通过这个例子，初学者可以更好地掌握这些概念，并将其应用于实际编程中。
Java prim生成迷宫，使用BFS算法寻路，并找到路径
最新发布
m0_71181165的博客
01-07 480
使用BFS(广度优先搜索)来寻路，并记录找到的最短路径。 Java迷宫寻路。
bfs-dfs.rar_BFS algoritm_BFS+c++
09-22
BFS通常用于找出两个节点之间的最短路径，尤其是在所有边的权重都相等的情况下。以下BFS的基本步骤： 1. **初始化队列**：将起始节点放入队列中。 2. **标记节点**：将起始节点标记为已访问。 3. **循环过程**： -...
迷宫的最短路径问题，分别用DFS和BFS做
yecuandu1534的博客
05-13 9046
迷宫的最短路径一般来说用BFS做，但是也可以用DFS做，如果最优路径只有一条的话，穷尽所有的路径然后找出路径最短的就好了。不废话，先上BFS代码，这个代码中，用到了每一个位置的前驱节点，需要记住。然后逆着路径打印出来。#include&lt;iostream&gt;#include&lt;vector&gt;#include&lt;queue&gt;using namespace std;type...
NYOJ99单词拼接（欧拉通路回路，dfs打印路径）
Winjourn的专栏
05-02 1229
单词拼接 时间限制：3000 ms  |  内存限制：65535 KB 难度：5 描述 给你一些单词，请你判断能否把它们首尾串起来串成一串。 前一个单词的结尾应该与下一个单词的道字母相同。 如 aloha dog arachnid gopher tiger rat   可以拼接成：aloha.arachnid.dog.gopher.rat.tiger 输入第一行
路径输出问题-（DFS）
miaobeihai的博客
03-02 859
在坐标系中，从（0,0）到（m,n),每次走一步，只能向上或者向右走，有多少种路径走到(m,n) (0,0) ->(2,2)   0.0- >1.0 ->2.0 ->2,1 ->2,2       1   0,0->1.0->1,1 ->2.1->2.2    2   0.0 -> 1.0 ->.1,1->1,2->2,2   3   0.0 -> 0.1- >0.2-
数据结构与算法分析（Java语言描述）（28）—— 使用 dfs 求两节点间的路径
HeatDeath的博客
11-20 641
package com.dataStructure.graph;import java.util.ArrayList; import java.util.List; import java.util.Stack;// 使用 dfs 获取两节点之间的路径public class Path { private Graph graph; // 输入的图 private boolean
DFS深搜经典算法
有朋自远方来，不亦乐乎。
12-01 585
输入样例： 5 4 1 1 2 1 1 1 1 1 1 1 2 1 1 2 1 1 1 1 1 2 1 1 4 3 输出： 7 代码： #include<iostream> using namespace std; int Endx, Endy; int Min = 1000; int map[100][100];//1是空地0是墙 int v[100][100];//访问数组0未访问7访问 void DFS(int x, int y, int step)//x，y表示当前
使用DFS求任意两点间所有路径
weixin_42033112的博客
04-17 3976
算法具体原理就不讲了，无非是当要返回到前一个结点时将该结点重新设置为未访问。 void DFS(int start, int end) { if (start == end) {//找到终点 path.push_back(start);//将终点加入path for (int i = 0; i < path.size(); i++) //输出路径 { if (i != p...
【ACM】【DFS】深搜打印所有经过的路径、打印最短路径
lesileqin的博客
04-07 1941
题目：给定一个大小为N*M的迷宫。迷宫由通道和墙壁组成，每一步可以向邻接的上下左右四个方向移动，请打印出所有能够到达目的地的路径。 样例输入： // “ S ” 表示起点、“ G ”表示重点、“ . ”表示通道、“ # ”表示墙壁 10 10 #S######.# ......#..# .#.##.##.# .#........ ##.##.#### ....#....# .####...
DFS--图中两点之间的路径
wan767912626的博客
04-11 2173
# include # include # include # define MAX 20 //最大顶点数 typedef struct VNODE { int num; //该边所指的顶点的位置 struct VNODE *next; //指向下一条边的指针 }arcnode; //表的结点 typedef struct LIST { char data;
直捣黄龙（多条件Dijkstra + dfs路径打印）
qq_51738428的博客
04-20 93
题目大意： 本题是一部战争大片 —— 你需要从己方大本营出发，一路攻城略地杀到敌方大本营。首先时间就是生命，所以你必须选择合适的路径，以最快的速度占领敌方大本营。当这样的路径不唯一时，要求选择可以沿途解放最多城镇的路径。若这样的路径也不唯一，则选择可以有效杀伤最多敌军的路径。 输入格式： 输入第一行给出 2 个正整数 N（2 ≤ N ≤ 200，城镇总数）和 K（城镇间道路条数），以及己方大本营和敌方大本营的代号。随后 N-1 行，每行给出除了己方大本营外的一个城镇的代...
使用DFS求任意两点的所有路径
weixin_30851867的博客
04-07 940
先上代码： public static void findAllPaths(Integer nodeId,Integer targetNodeId, Map<Integer,ArrayList<Integer>> reachMap) { for (Integer nextNode : reachMap.get(nodeId)) { ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值