#算法04 bfs

最新推荐文章于 2024-10-17 11:39:06 发布

__zm_

最新推荐文章于 2024-10-17 11:39:06 发布

阅读量175

点赞数 7

文章标签：宽度优先算法

本文链接：https://blog.csdn.net/qq_52551514/article/details/136886520

版权

本文介绍了如何通过广度优先搜索（BFS）算法解决一个关于初始状态下三个不同容量桶之间的牛奶转移问题，BFS避免了深度优先搜索可能导致的栈溢出，并能找到最短路径。作者详细解释了状态转移规则并提供了C++代码实现。

摘要由CSDN通过智能技术生成

bfs利用队列实现，由内向外逐渐扩展进行搜索，也就是会先枚举当前状态的所有转移状态。

代码量通常比dfs多很多，优点是不会爆栈，并且可以轻松得到最短路径长度。

1、母亲的牛奶

题目大意是初始状态下有三个桶，容量分别为A,B,C,开始A,B桶均为空，C桶是满的。

可以将C桶中的奶倒入A或者B中，当c桶中牛奶倒完或被倒的的满了，即可停止本次倒牛奶，A，B向其他的桶中倒牛奶类似，试问c桶中的牛奶会有哪些情况，按从小到大输出。

思路：可以把三个桶看成一个三元组(A B C)，从初始状态开始转移状态，最后输出A等于0状态的

C值。转移状态的方式就是以第i桶向第j桶转移为例，转移量为

min（i桶的牛奶量， j桶还能装多少牛奶（也就是j桶的容量 - 当前j的牛奶量））

通过组合知识可以知道，一共有3 * 2 = 6种状态（先从三个桶中选一个，然后剩下的桶有两个可以转移牛奶）。

知识点：bfs先枚举当前状态的所有转移状态。

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
int A, B, C;
const int N = 22, M = N * N * N;
struct milk
{
    int a, b, c;
}arr[M];
bool st[N][N][N];


void bfs()
{
    st[0][0][C] = true;
    int hh = 0, tt = 0;
    arr[hh] = {0, 0, C};
    int W[3] = {A, B, C};

    while (hh <= tt)
    {
        int ta = arr[hh].a, tb = arr[hh].b, tc = arr[hh ++].c;

        for (int i = 0; i < 3; i ++)
            for (int j = 0; j < 3; j ++)
            {
                if (i == j) continue;
                int w[3] = {ta, tb, tc};
                int temp = min(w[i], W[j] - w[j]);
                w[i] -= temp, w[j] += temp;

                if(!st[w[0]][w[1]][w[2]]) 
                {
                    st[w[0]][w[1]][w[2]] = true;
                    arr[++ tt] = {w[0], w[1], w[2]};
                }
            }
    }


}


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 << " ";
                break;
            }
    return 0;
}