1355. 母亲的牛奶 bfs dfs

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

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

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

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

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

输入格式

共一行，包含三个整数 A,B,C。

输出格式

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

数据范围

1≤A,B,C≤2

输入样例1：

8 9 10

输出样例1：

1 2 8 9 10

输入样例2：

2 5 10

输出样例2：

5 6 7 8 9 10

先看bfs的：

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

using namespace std;

const int N = 21, M = N * N * N;

int A, B, C;
struct Node//定义一个结构体来存储每种情况（用三元组）
{
    int a, b, c;
}q[M];
bool st[N][N][N];//看看这种情况有没有被遍历过，全局变量默认false

void bfs()
{
    //模拟队列
    int hh = 0, tt = 0;//队头队尾
    q[0] = {0, 0, C};//初始状态，只有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)  // 从桶i往桶j中倒   ，    自己不能往自己里面倒
                {
                    int w[3] = {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[ ++ tt] = {a, b, c};//加进去
                    }
                }
    }
}

int main()
{
    scanf("%d%d%d", &A, &B, &C);//输入每个桶的容积
    bfs();
    //枚举bc两个桶
    for (int c = 0; c <= C; c ++ )
        for (int b = 0; b <= B; b ++ )
            if (st[0][b][c])//看看当a桶为0的时候c有多少状态
            {
                printf("%d ", c);
                break;
            }

    return 0;
}

算法2(dfs)
(暴力枚举) O(ABC)
同样也是暴力枚举每一种情况

思考我们的递归终止条件什么，显然不是a,b,c出界，而是这个状态被遍历过，那么必然也从这个状态转移过，所以在此便可终止递归，在遍历到每一个状态的时候，标记为true,，千万不要回溯。 因为如果回溯了，那么在最后统计答案的时候会所有状态都没有被访问过，那么如果我们在结束递归的同时输出答案会使得答案重复，而且无法保证c值从小到大

然后输出答案是外层循环枚举c, 内层枚举b，才能从小到大输出哦

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

using namespace std;

const int N = 21;

int A, B, C;
bool vis[N][N][N];

void dfs(int a, int b, int c) {
    if (vis[a][b][c]) return;
    vis[a][b][c] = true;
    dfs(a - min(a, B - b), min(a + b, B), c);
    dfs(a- min(a, C - c), b, min(a + c, C));
    dfs(min(a + b, A), b - min(b, A - a), c);
    dfs(a, b - min(b, C- c), min(c + b, C));
    dfs(min(a + c, A), b, c - min(c, A - a));
    dfs(a, min(b + c, B), c - min(c, B - b));
}

int main(void) {
    scanf("%d%d%d", &A, &B, &C);

    dfs(0, 0, C);


    for (int c = 0; c <= C; c ++ ) 
        for (int b = 0; b <= B; b ++ ) 
            if(vis[0][b][c]) {
                cout << c << ' ';
                break;
            }

    return 0;
}

求的是c从小到大输出，模拟一下循环，举个例子：外层如果c=1，内层遍历b从1到B，发现存在使得a=0的情况，则输出1，然后遍历c=2的情况（外层c=2，内层遍历b从1到B），假设没有符合的，则跳至c=3的情况继续遍历，这时发现有则输出3，这样可以实现从小到大输出。