蓝桥杯 BFS

稻禾边的阳光

已于 2024-03-23 11:44:09 修改

阅读量229

点赞数 4

分类专栏： # 蓝桥杯每日一题文章标签：蓝桥杯宽度优先算法

于 2024-03-21 22:05:24 首次发布

本文链接：https://blog.csdn.net/qq_45888225/article/details/136919613

版权

蓝桥杯每日一题专栏收录该内容

12 篇文章 0 订阅

订阅专栏

BFS(所有边权都是1可以做最短路)

1. 走迷宫

给定一个 n×m 的二维整数数组，用来表示一个迷宫，数组中只包含 0 或 1，其中 0 表示可以走的路，1 表示不可通过的墙壁。

最初，有一个人位于左上角 (1,1) 处，已知该人每次可以向上、下、左、右任意一个方向移动一个位置。

请问，该人从左上角移动至右下角 (n,m) 处，至少需要移动多少次。

数据保证 (1,1) 处和 (n,m) 处的数字为 0，且一定至少存在一条通路。

输入格式
第一行包含两个整数 n 和 m。

接下来 n 行，每行包含 m 个整数（0 或 1），表示完整的二维数组迷宫。

输出格式
输出一个整数，表示从左上角移动至右下角的最少移动次数。

数据范围
1≤n,m≤100
输入样例：

输出样例：

解题思路：宽度遍历
步骤：

queue <-- 初始状态
while(queue 不空)
{
		t <-- 把队头拿出来
		拓展t
}

#include<iostream>
#include<algorithm>
#include<cstring>

using namespace std;

typedef pair<int, int> PII;

const int N = 110;
int n, m;
int g[N][N], d[N][N];
PII path[N][N], q[N * N];
int dx[] = {1, -1, 0, 0}, dy[] = {0, 0, 1, -1};

int dfs()
{
    int hh = 0, tt = 0;
    q[0] = {0, 0};
    memset(d, -1, sizeof d);
    d[0][0] = 0;
    while(hh <= tt)
    {
        auto t = q[hh++];
        for(int i = 0; i < 4; i++)
        {
            int x = t.first + dx[i], y = t.second + dy[i];
            if(x >= 0 && x < n && y >= 0 && y < m && g[x][y] == 0 && d[x][y] == -1)
            {
                d[x][y] = d[t.first][t.second] + 1;
                path[x][y] = t;
                q[++tt] = {x, y};
            }
        }
    }
    int x = n - 1, y = m - 1;
    while(x || y)
    {
        cout << x << " " << y << endl;
        auto t = path[x][y];
        x = t.first, y = t.second;
    }
    return d[n - 1][m - 1];
}

int main()
{
    cin >> n >> m;
    for(int i = 0; i < n; i++)
        for(int j = 0; j < m; j++)
            cin >> g[i][j];
    cout << dfs() << endl;
    return 0;
}

2. 图中点的层次

给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环。

所有边的长度都是 1，点的编号为 1∼n。

请你求出 1 号点到 n 号点的最短距离，如果从 1 号点无法走到 n 号点，输出 −1。

输入格式
第一行包含两个整数 n 和 m。

接下来 m 行，每行包含两个整数 a 和 b，表示存在一条从 a 走到 b 的长度为 1 的边。

输出格式
输出一个整数，表示 1 号点到 n 号点的最短距离。

数据范围
1≤n,m≤105
输入样例：

输出样例：

解题思路：边权重为1，bfs求最短路。

#include<iostream>
#include<cstring>
#include<algorithm>

using namespace std;

const int N = 1e5 + 10;
int n, m;
int h[N], e[N * 2], ne[N * 2], idx;
int q[N], d[N];

void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}

int bfs()
{
    memset(d, -1, sizeof d);
    d[1] = 0;
    q[0] = 1;
    int hh = 0, tt = 0;
    while(hh <= tt)
    {
        int t = q[hh++];
        for(int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            if(d[j] == -1)
            {
                d[j] = d[t] + 1;
                q[++tt] = j;
            }
        }
    }
    return d[n];
}

int main()
{
    memset(h, -1, sizeof h);
    cin >> n >> m;
    for(int i = 0; i < m; i++)
    {
        int a, b;
        cin >> a >> b;
        add(a, b);
    }
    cout << bfs() << endl;
    return 0;
}

3. 八数码

在一个 3×3 的网格中，1∼8 这 8 个数字和一个 x 恰好不重不漏地分布在这 3×3 的网格中。

例如：

1 2 3
x 4 6
7 5 8

在游戏过程中，可以把 x 与其上、下、左、右四个方向之一的数字交换（如果存在）。

我们的目的是通过交换，使得网格变为如下排列（称为正确排列）：

1 2 3
4 5 6
7 8 x

例如，示例中图形就可以通过让 x 先后与右、下、右三个方向的数字交换成功得到正确排列。

交换过程如下：

1 2 3   1 2 3   1 2 3   1 2 3
x 4 6   4 x 6   4 5 6   4 5 6
7 5 8   7 5 8   7 x 8   7 8 x

现在，给你一个初始网格，请你求出得到正确排列至少需要进行多少次交换。

输入格式
输入占一行，将 3×3 的初始网格描绘出来。

例如，如果初始网格如下所示：

1 2 3
x 4 6
7 5 8
则输入为：1 2 3 x 4 6 7 5 8

输出格式
输出占一行，包含一个整数，表示最少交换次数。

如果不存在解决方案，则输出 −1。

输入样例：

2 3 4 1 5 x 7 6 8

输出样例

解题思路：
问题：

怎么表示一种情况使其能作为结点？
任何记录每个状态的“距离”
队列怎么定义，dist数组怎么定义
解决：
将 3*3矩阵转化为字符串
队列可以用 queue<string>
dist数组可以用 unordered_map<string, int>
//将字符串和数字联系起来，字符串表示状态，数字表示距离
矩阵与字符串的转换方式

代码

#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>
#include<unordered_map>

using namespace std;

queue<string> q;
unordered_map<string, int> dist;

int bfs(string start)
{
    string end = "12345678x";
    q.push(start);
    dist[start] = 0;
    int dx[] = {1, -1, 0, 0}, dy[] = {0, 0, 1, -1};
    while(q.size())
    {
        auto t = q.front();
        q.pop();
        int distance = dist[t];
        if(t == end) return distance;
        int k = t.find('x');
        int x = k / 3, y = k % 3;
        for(int i = 0; i < 4; i++)
        {
            int a = x + dx[i], b = y + dy[i];
            if(a >= 0 && a < 3 && b >= 0 && b < 3)
            {
                swap(t[k], t[a * 3 + b]);
                if(!dist.count(t))
                {
                    dist[t] = distance + 1;
                    q.push(t);
                }
                swap(t[k], t[a * 3 + b]);
            }
        }
    }
    return -1;
}

int main()
{
    string start;
    char c;
    for(int i = 0; i < 9; i++)
    {
        cin >> c;
        start += c;
    }
    cout << bfs(start) << endl;
    return 0;
}

4. 母亲的牛奶

农夫约翰有三个容量分别为 A,B,C 升的挤奶桶。

最开始桶 A 和桶 B 都是空的，而桶 C 里装满了牛奶。

有时，约翰会将牛奶从一个桶倒到另一个桶中，直到被倒入牛奶的桶满了或者倒出牛奶的桶空了为止。

这一过程中间不能有任何停顿，并且不会有任何牛奶的浪费。

请你编写一个程序判断，当 A 桶是空的时候，C 桶中可能包含多少升牛奶，找出所有的可能情况。

输入格式
共一行，包含三个整数 A,B,C。

输出格式
共一行，包含若干个整数，表示 C 桶中牛奶存量的所有可能情况，请将这些数字按升序排列。

数据范围

1≤A,B,C≤20

输入样例1：

8 9 10

输出样例1：

1 2 8 9 10

输入样例2：

2 5 10

输出样例2：

5 6 7 8 9 10

代码

#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>

using namespace std;

struct m{
    int a, b, c;
};

const int N = 21;
int A, B, C;
queue<m> q; //不用定义长度
bool st[N][N][N];

void bfs()
{
    int W[] = {A, B, C};
    q.push({0, 0, C});
    st[0][0][C] = true;
    while(q.size())
    {
        auto t = q.front();
        q.pop();
        for(int i = 0; i < 3; i++)
            for(int j = 0; j < 3; j++)
            {
                int w[] = {t.a, t.b, t.c};  //每次要初始化
                int r = min(w[i], W[j] - w[j]);
                w[i] -= r, w[j] += r;
                int a = w[0], b = w[1], c = w[2];
                if(!st[a][b][c])
                {
                    st[a][b][c] = true;
                    q.push({a, b, c});
                }
            }
    }
}

int main()
{
    cin >> A >> B >> C;
    bfs();
    for(int c = 0; c <= C; c++)
        for(int b = 0; b <= B; b++)
            {
                if(st[0][b][c])
                    cout << c << " ";
            }
    return 0;
}