题目描述：

农夫约翰有三个容量分别为 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

分析步骤：

  第一：拿到这道题目，我们可以知道我们有三个桶，里面只有C桶是满的，我们要将它倒入其他的木桶，只要A是空的，记录一下这时C木桶的牛奶量。我们可以用一个结构体，里面含有a,b,c三木桶的奶量，再用一个三维数组，记录下这三个木桶的所有情况。到时候只要A是为0并且这个三维数组能够遍历的到就代表会有这种情况，就输出C的值就可以。其中A桶a种情况，B桶b种情况，C桶c种情况，相乘共a*b*c种情况，那么这种情况下的最大时间复杂度是20*20*20,爆搜所有情况可行，那么现在的问题是共c桶奶，分别放入A，B，C即可

  第二：书写主函数，构建整体框架。

             先输入A,B,C这三个木桶的容量，在进入BFS去搜索，最终搜索完毕之后，用for循环一下找出A为0时并且这个数组能够遍历到的情况下，就输出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])
            {
                printf("%d ", c);
                break;
            }
    
    return 0;
}

  第三：书写BFS函数

             各位，我们书写bfs函数都是采用队列来储存的，本文采用手写队列的方式。

             首先定义，首尾节点为0，将（0，0，c）放入队列，因为一开始只能是c木桶装满奶，其他两个木桶是没有奶的。最后将这个情况定义为true，用W[3]（大写）来储存A,B,C三个木桶的容量。

             其次，进入while循环，只要队列不空就一直循环，用迭代器自动向后遍历。用for循环遍历三个木桶，这里是木桶i 将牛奶倒入 木桶j，不过自己不能将牛奶倒入自己。w[3]（小写）代表现在的奶量，定义一个r用来动态更新，我们不能倒入超过 木桶i 现在的奶量，也不能倒入超过木桶j的剩余容量将他们两个取最小值。将木桶i倒出r 木桶j倒入r，定义a,b,c分别为三个木桶调整后的奶量。在判断一下是否出现过这种情况，如果没有出现过，就将此点入队，更新一下状态。

void bfs(){
     int hh = 0  , tt = 0 ; 
     q[0] = {0,0,C};
     st[0][0][C] = true;
     int W[3] = {A,B,C};
     
     while(hh <= tt){
     auto t = q[hh++];
     for(int i = 0 ; i < 3 ; i ++){
         for(int j = 0 ; j < 3 ; j ++){
             if(i != j){
                 int w[3] = {t.a,t.b,t.c};
                 int r = min (w[i] , w[j] - w[i]);
                  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[ ++ tt] = {a, b, c};
                    }
             }
         }
     }
     
     }
}

代码：

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

using namespace std;

const int N = 21, M = N * N * N;  // 数组的最大大小

struct node {
    int a, b, c;  // 三个水壶的水量
} q[M];  // 用于存储状态的数组
int A, B, C;  // 三个水壶的容量
bool st[N][N][N];  // 用于标记访问过的状态

void bfs() {
    int hh = 0, tt = 0;  // 队列头和尾的指针
    q[0] = {0, 0, C};  // 初始状态：第三个水壶满
    st[0][0][C] = true;  // 标记初始状态为已访问
    int W[3] = {A, B, C};  // 三个水壶的容量

    while (hh <= tt) {
        auto t = q[hh++];  // 出队下一个状态
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                if (i != j) {
                    int w[3] = {t.a, t.b, t.c};  // 复制当前状态
                    int r = min(w[i], w[j] - w[i]);  // 计算需要倒水的量
                    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[++tt] = {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]) {
                printf("%d ", c);  // 输出可能的第三个水壶的水量
                break;
            }
        }
    }
    return 0;
}