BFS - 标签 - 菠菜眾長https://lruihao.cn/tags/bfs/BFS - 标签 - 菠菜眾長Hugo -- gohugo.iozh-CN1024@lruihao.cn (Lruihao)1024@lruihao.cn (Lruihao)Sun, 22 Jul 2018 12:10:32 +0000POJ-3278-Catch That Cow(bfs)https://lruihao.cn/posts/poj-3278/Sun, 22 Jul 2018 12:10:32 +0000Lruihaohttps://lruihao.cn/posts/poj-3278/Farmer John has been informed of the location of a fugitive cow and wants to catch her immediately. He starts at a point N (0 ≤ N ≤ 100,000) on a number line and the cow is at a point K (0 ≤ K ≤ 100,000) on the same number line. Farmer John has two modes of transportation: walking and teleporting.

  • Walking: FJ can move from any point X to the points X",“1 or X + 1 in a single minute
  • Teleporting: FJ can move from any point X to the point 2 × X in a single minute.

If the cow, unaware of its pursuit, does not move at all, how long does it take for Farmer John to retrieve it?

Input

Line 1: Two space-separated integers: N and K

Output

Line 1: The least amount of time, in minutes, it takes for Farmer John to catch the fugitive cow.

Sample Input

5 17

Sample Output

4

Hint

The fastest way for Farmer John to reach the fugitive cow is to move along the following path: 5-10-9-18-17, which takes 4 minutes.

题意：

农场主的牛不见了，主人和牛在一条直线上，且牛没有新的目标，它不会走动，主人的位置是你 n，牛的位置是 k，主人可以有三种走路的方法，右左（距离+-1），闪现（距离+x,x 为当前位置），每走一步，一分钟，问几分钟主人能找到牛。bfs 搜索方向即为三个“方向”。搜索所有走法；

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

#include"iostream"
#include<queue>
#include"string.h"
using namespace std;

int n,k;
bool sign[200007];

struct node{
    int x,step;
};

bool check(int a)
{
    if(!sign[a]&&a>=0&&a<110000)
        return true;
    return false;
}

void bfs()
{
    node u,v;
    queue<node> q;
    v.x=n;//初始化起点
    v.step=0;
    q.push(v);
    sign[v.x]=true;
    while(!q.empty()){
        u=q.front();
        q.pop();
        if(u.x==k){
            cout<<u.step<<endl;
            return ;
        }

        //三种前进方向，左右和闪现
        v=u;
        v.x++;
        v.step++;
        if(check(v.x)){
            sign[v.x]=true;
            q.push(v);
        }

        v=u;
        v.x--;
        v.step++;
        if(check(v.x)){
            sign[v.x]=true;
            q.push(v);
        }

        v=u;
        v.x=2*v.x;
        v.step++;
        if(check(v.x)){
            sign[v.x]=true;
            q.push(v);
        }
    }
}

int main()
{
    cin>>n>>k;
    memset(sign,0,sizeof(sign));
    bfs();
    return 0;
}
]]>poj-2251-Dungeon Master（三维 bfs 最短路）https://lruihao.cn/posts/poj-2251/Sun, 22 Jul 2018 12:02:32 +0000Lruihaohttps://lruihao.cn/posts/poj-2251/英文原题链接

Description - 题目描述

你被困在一个三维的空间中，现在要寻找最短路径逃生！
空间由立方体单位构成
你每次向上下前后左右移动一个单位需要一分钟
你不能对角线移动并且四周封闭
是否存在逃出生天的可能性？如果存在，则需要多少时间？

Input - 输入

输入第一行是一个数表示空间的数量。
每个空间的描述的第一行为 L，R 和 C（皆不超过 30）。
L 表示空间的高度。R 和 C 分别表示每层空间的行与列的大小。
随后 L 层地牢，每层 R 行，每行 C 个字符。
每个字符表示空间的一个单元。’#‘表示不可通过单元，’.‘表示空白单元。你的起始位置在’S’，出口为’E’。
每层空间后都有一个空行。L，R 和 C 均为 0 时输入结束。

Output - 输出

每个空间对应一行输出。
如果可以逃生，则输出如下
Escaped in x minute(s).

x 为最短脱离时间。

如果无法逃生，则输出如下

Trapped!

Sample Input - 输入样例

3 4 5
S....
.###.
.##..
###.#

#####
##.##
##...

#####
#.###
####E

1 3 3
S##
#E#
###

0 0 0

Sample Output - 输出样例

Escaped in 11 minute(s).
Trapped!

类似二维四个方向的 bfs 最短路，改成上下东西南北就行了，三维 bfs 最短路

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <queue>
#include <algorithm>
using namespace std;

char map[35][35][35];
int vis[35][35][35];
int k,n,m,sx,sy,sz,ex,ey,ez;
int to[6][3] = {{0,0,1},{0,0,-1},{0,1,0},{0,-1,0},{1,0,0},{-1,0,0}};//上下东西南北

struct node
{
    int x,y,z,step;
};

int check(int x,int y,int z)//检查是否可走
{
    if(x<0 || y<0 || z<0 || x>=k || y>=n || z>=m)//越界判断
        return 1;
    else if(map[x][y][z] == '#')
        return 1;
    else if(vis[x][y][z])
        return 1;
    return 0;
}

int bfs()
{
    int i;
    node a,next;
    queue<node> Q;
    a.x = sx,a.y = sy,a.z = sz;
    a.step = 0;
    vis[sx][sy][sz] = 1;
    Q.push(a);
    while(!Q.empty())
    {
        a = Q.front();
        Q.pop();
        if(a.x == ex && a.y == ey && a.z == ez)
            return a.step;
        for(i = 0; i<6; i++)
        {
            next = a;
            next.x = a.x+to[i][0];
            next.y = a.y+to[i][1];
            next.z = a.z+to[i][2];
            if(check(next.x,next.y,next.z))
                continue;
            vis[next.x][next.y][next.z] = 1;
            next.step = a.step+1;
            Q.push(next);
        }
    }
    return 0;
}

int main()
{
    int i,j,r;
    while(scanf("%d%d%d",&k,&n,&m),n+m+k)
    {
        for(i = 0; i<k; i++)
        {
            for(j = 0; j<n; j++)
            {
                scanf("%s",map[i][j]);
                for(r = 0; r<m; r++)
                {
                    if(map[i][j][r] == 'S')
                    {
                        sx = i,sy = j,sz = r;
                    }
                    else if(map[i][j][r] == 'E')
                    {
                        ex = i,ey = j,ez = r;
                    }
                }
            }
        }
        memset(vis,0,sizeof(vis));
        int ans;
        ans = bfs();
        if(ans)
            printf("Escaped in %d minute(s).\n",ans);
        else
            printf("Trapped!\n");
    }

    return 0;
}
]]>poj-3984-迷宫问题 (bfs 路径）https://lruihao.cn/posts/poj-3984/Sun, 22 Jul 2018 11:50:20 +0000Lruihaohttps://lruihao.cn/posts/poj-3984/迷宫问题

Time Limit: 1000MS Memory Limit: 65536K
Total Submissions: 32323 Accepted: 18471

Description

定义一个二维数组：

int maze[5][5] = {
	0, 1, 0, 0, 0,
	0, 1, 0, 1, 0,
	0, 0, 0, 0, 0,
	0, 1, 1, 1, 0,
	0, 0, 0, 1, 0,
};

它表示一个迷宫，其中的 1 表示墙壁，0 表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。

Input

一个 5 × 5 的二维数组，表示一个迷宫。数据保证有唯一解。

Output

左上角到右下角的最短路径，格式如样例所示。

Sample Input

0 1 0 0 0
0 1 0 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0

Sample Output

(0, 0)
(1, 0)
(2, 0)
(2, 1)
(2, 2)
(2, 3)
(2, 4)
(3, 4)
(4, 4)

对于新手来说，主要是 bfs 路径的问题有点难度，搞得晕晕的。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

#include<iostream>
#include<cstring>
using namespace std;
int map[5][5];
int visited[5][5];
int dx[4]={0, 1, 0, -1};
int dy[4]={ 1, 0,-1, 0};
int head,tail;
struct node{
	int xx,yy;
	int fa;//父节点
}pre[25],way[25];

void BFS(int x,int y)
{
	int x1,y1;
	head=0,tail=1;
	visited[x][y]=1;
	pre[0].xx=x,pre[0].yy=y;

	while(tail>head)//栈空
	{
		x=pre[head].xx;
		y=pre[head].yy;
		if(x==4&&y==4)//结束标志
			return ;
		for(int i=0;i<4;i++)
		{
			x1=x+dx[i];y1=y+dy[i];
			if(x1>=0&&x1<=4&&y1>=0&&y1<=4)
				if(map[x1][y1]==0&&!visited[x1][y1])
				{
					pre[tail].xx=x1;
					pre[tail].yy=y1;
					pre[tail].fa=head;
					visited[x1][y1]=1;
					tail+=1;//入栈
				}
		}
		head++;//相当于出栈
	}
}
int main()
{
	int i,j;
	ios::sync_with_stdio(false);
	memset(map,0,sizeof(map));
	memset(visited,0,sizeof(visited));
	for(i=0;i<5;i++)
		for(j=0;j<5;j++)
			cin>>map[i][j];
	BFS(0,0);
	i=0;
	while(head)//逆序进行赋值输出就是通路
	{
		way[i].xx=pre[head].xx;
		way[i].yy=pre[head].yy;
		head=pre[head].fa;
		i++;
	}
	//画一下队列
	way[i].xx=0;way[i].yy=0;
	while(i!=-1)
	{
		cout<<"("<<way[i].xx<<", "<<way[i].yy<<")"<<endl;
		i--;
	}
	return 0;
}
]]>BFS 求最短路https://lruihao.cn/posts/bfs%E6%B1%82%E6%9C%80%E7%9F%AD%E8%B7%AF/Sun, 22 Jul 2018 11:31:05 +0000Lruihaohttps://lruihao.cn/posts/bfs%E6%B1%82%E6%9C%80%E7%9F%AD%E8%B7%AF/假设有一个 n 行 m 列的迷宫，每个单位要么是空地（用 1 表示）要么是障碍物（用 0 表示）.
如和找到从起点到终点的最短路径？利用 BFS 搜索，逐步计算出每个节点到起点的最短距离，
以及最短路径每个节点的前一个节点。最终将生成一颗以起点为根的 BFS 树。此时 BFS 可以求出任意一点到起点的距离。

图

1 3  0 21 23
2 0 17 20 22
4 0 14  0  0
5 0 12 15 18
6 8 10  0 19
7 9 11 13 16

输入

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

输出

1 2 4 5 6 8 10 12 14 17 20 21 23
12//最短距离

代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

#include<iostream>
#include<queue>
#include<cstdio>
#include<cstring>
#include<vector>
using namespace std;
const int maxn=100+5;

int G[maxn][maxn];   //存图的 d=id
int path[maxn];      //存每个节点的父节点，即路径
int n,m;             //n 行   m 列
int k=1;//记录编号
int end_num;
int vx[5] = {-1,1,0,0};   //vx  vy 用来计算一个节点周围上下左右 4 个节点
int vy[5] = {0,0,-1,1};
bool vis[maxn][maxn];     //判断某节点是否已经被访问过

struct node
{
    int x;
    int y;
    int id;
    int parent=0;
    node(int a,int b,int c)
    {
        x=a;
        y=b;
        id=c;
    }
};

int main()
{
    //freopen("in.txt","r",stdin);
    memset(G,0,sizeof(G));
    memset(vis,0,sizeof(vis));
    memset(path,0,sizeof(path));
    cin>>n>>m;
    for(int i=1; i<=n; i++)
        for(int j=1; j<=m; j++)
        {
            cin>>G[i][j];
        }
    queue<node> q;
    node v=node(1,1,1);
    q.push(v);
    vis[1][1]=1;
    while(!q.empty())
    {
        node u=q.front();
        q.pop();
        path[u.id]=u.parent;//记录每个点的父节点
        for(int i=0; i<4; i++)
        {
            int tx=u.x+vx[i];
            int ty=u.y+vy[i];
            if(G[tx][ty]&&!vis[tx][ty])//有路可走且未访问
            {
                vis[tx][ty]=1;
                //cout<<tx<<ty<<endl;
                node v=node(tx,ty,++k);
                end_num=k;
                v.parent=u.id;
                q.push(v);
            }
        }
    }
    vector<int> ans;
    //cout<<end_num<<endl;
    while(end_num)//从后面开始找父亲节点
    {
        ans.push_back(end_num);
        end_num=path[end_num];
    }
    int s=0;
    while(!ans.empty())
    {
        s++;
        cout<<*(ans.end()-1)<<' ';//ans 最后一个元素是 0
        ans.pop_back();
    }
    cout<<endl<<s-1;
    return 0;
}
]]>深搜广搜https://lruihao.cn/posts/dfs_bfs/Sun, 22 Jul 2018 11:25:14 +0800Lruihaohttps://lruihao.cn/posts/dfs_bfs/广度优先搜索（BFS）

广度优先搜索在进一步遍历图中顶点之前，先访问当前顶点的所有邻接结点。访问了就入队。

深度优先搜索（DFS）

深度优先搜索在搜索过程中访问某个顶点后，需要递归地访问此顶点的所有未访问过的相邻顶点。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

#include <bits/stdc++.h>
#define N 5
using namespace std;
int maze[N][N] = {//无权有向图邻接矩阵
     { 0, 1, 0, 1, 0 },
     { 0, 0, 1, 0, 0 },
     { 0, 0, 0, 0, 1 },
     { 0, 0, 1, 0, 0 },
     { 0, 0, 0, 0, 0 }
 };
 int visited[N];
 void DFS(int start)
 {
     cout << start<< " ";
     visited[start] = 1;
     for (int i = 0; i < N; i++)
     {
         if (!visited[i] && maze[start][i] == 1)//没访问过且为邻居节点
             DFS(i);
     }
 }
 void BFS(int start){
     queue<int> Q;//队列
     Q.push(start);
     visited[start] = 1;
     while (!Q.empty())
     {
         int front = Q.front();//头
         cout << front << " ";
         Q.pop();
         for (int i = 0; i <N; i++)
         {
             if (!visited[i] && maze[front][i] == 1)
             {
                 visited[i] = 1;
                 Q.push(i);
             }
         }
     }
 }

 int main()
 {
     memset(visited,0,sizeof(visited));
     for (int i = 0; i < N; i++)//不连通的情况
     {
         if (visited[i] == 1)//访问过
             continue;
         DFS(i);
     }
     cout<<endl;
     memset(visited,0,sizeof(visited));
     for (int i = 0; i < N; i++)//不连通的情况
     {
         if (visited[i] == 1)//访问过
             continue;
         BFS(i);
     }
     return 0;
 }

传送门

]]>