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
#include <cstdio>
#include <queue>

bool p[3][100005]; // (i,j) -> i-ty jest pierwszym pełnym, w poprzednim cyklicznie jest j
bool q[3][100005]; // (i,j) -> i-ty jest pierwszym pustym, w poprzednim cyklicznie jest j
int d[100005]; // wyniki

struct t { int a[3]; int d; };

int main()
{
    int A[3], a[3], b[3];
    scanf("%d%d%d%d%d%d", &A[0], &A[1], &A[2], &a[0], &a[1], &a[2]);
    
    std::fill(&p[0][0], &p[0][0] + 3*100005, false);
    std::fill(&q[0][0], &q[0][0] + 3*100005, false);
    std::fill(&d[0], &d[0] + 100005, -1);
    
    std::queue<t> pending;
    
    pending.push({a[0],a[1],a[2],0});
    
    while (!pending.empty())
    {
        t x = pending.front();
        pending.pop();
        
        for (int i = 0; i < 3; i++)
            if (d[x.a[i]] == -1)
                d[x.a[i]] = x.d;
        
        for (int i = 0; i < 3; i++)
            for (int j = 0; j < 3; j++)
            {
                if (j == i) continue;
                
                std::copy(x.a, x.a + 3, b);
                b[i] += b[j];
                b[j] = 0;
                if (b[i] > A[i])
                {
                    b[j] = b[i] - A[i];
                    b[i] = A[i];
                }
                
                int k;
                for (k = 0; k < 3 && b[k] < A[k]; k++);
                
                if (k < 3) // istnieje pełna butelka
                {
                    bool& tmp = p[k][b[(k+2)%3]];
                    if (!tmp)
                    {
                        tmp = true;
                        pending.push({b[0],b[1],b[2],x.d+1});
                    }
                }
                else // nie istnieje pełna butelka
                {
                    for (k = 0; b[k] > 0; k++);
                    
                    bool& tmp = q[k][b[(k+2)%3]];
                    if (!tmp)
                    {
                        tmp = true;
                        pending.push({b[0],b[1],b[2],x.d+1});
                    }
                }
            }
    }
    
    printf("%d", d[0]);
    
    for (int i = 1; i <= A[2]; i++)
        printf(" %d", d[i]);
    
    printf("\n");
    
    return 0;
}