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
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
#include <iostream>
#include <tuple>
#include <queue>
#include <set>
#include <algorithm>

const int maxN = 100 * 1000 + 20;

int solution[maxN];
std::priority_queue<std::pair<int, long long>> qu;
std::set<long long> checked;

int A[3];
int a[3];
int n;

int prio;
std::pair<int, long long> give;
long long paczka;

long long pack(int x, int y, int z){
        return
                (long long) x * maxN * maxN
                + (long long) y * maxN
                + (long long) z;
}

void unpack(long long v, int& x, int& y, int& z){
        z = v % maxN;
        v /= maxN;
        y = v % maxN;
        v /= maxN;
        x = v;
}

void move(int i, int j){
        a[j] += a[i];
        if(a[j] > A[j]){
                a[i] -= a[j] - A[j];
                a[j] = 0;
        } else a[i] = 0;
}

int main(){

        std::cin >> A[0] >> A[1] >> A[2];
        std::cin >> a[0] >> a[1] >> A[2];

        n = A[2] + 1;

        for(int i = 0; i < n; i++)
                solution[i] = INT32_MAX;

        paczka = pack(a[0], a[1], a[2]);
        give = std::pair<int, long long>(0, paczka);
        qu.push(give);
        checked.insert(paczka);

        while(qu.empty() == false){
                give = qu.top();
                qu.pop();
                prio = -1 * give.first;
                prio++;

                paczka = give.second;
                unpack(paczka, a[0], a[1], a[2]);
                move(0, 1);
                paczka = pack(a[0], a[1], a[2]);
                if(checked.count(paczka) == 0){
                        checked.insert(paczka);
                        solution[a[0]] = std::min(solution[a[0]], prio);
                        solution[a[1]] = std::min(solution[a[1]], prio);
                        solution[a[2]] = std::min(solution[a[2]], prio);
                        qu.push(std::pair<int, long long>(prio * -1, paczka));
                }

                paczka = give.second;
                unpack(paczka, a[0], a[1], a[2]);
                move(1, 0);
                paczka = pack(a[0], a[1], a[2]);
                if(checked.count(paczka) == 0){
                        checked.insert(paczka);
                        solution[a[0]] = std::min(solution[a[0]], prio);
                        solution[a[1]] = std::min(solution[a[1]], prio);
                        solution[a[2]] = std::min(solution[a[2]], prio);
                        qu.push(std::pair<int, long long>(prio * -1, paczka));
                }

                paczka = give.second;
                unpack(paczka, a[0], a[1], a[2]);
                move(0, 2);
                paczka = pack(a[0], a[1], a[2]);
                if(checked.count(paczka) == 0){
                        checked.insert(paczka);
                        solution[a[0]] = std::min(solution[a[0]], prio);
                        solution[a[1]] = std::min(solution[a[1]], prio);
                        solution[a[2]] = std::min(solution[a[2]], prio);
                        qu.push(std::pair<int, long long>(prio * -1, paczka));
                }

                paczka = give.second;
                unpack(paczka, a[0], a[1], a[2]);
                move(2, 0);
                paczka = pack(a[0], a[1], a[2]);
                if(checked.count(paczka) == 0){
                        checked.insert(paczka);
                        solution[a[0]] = std::min(solution[a[0]], prio);
                        solution[a[1]] = std::min(solution[a[1]], prio);
                        solution[a[2]] = std::min(solution[a[2]], prio);
                        qu.push(std::pair<int, long long>(prio * -1, paczka));
                }

                paczka = give.second;
                unpack(paczka, a[0], a[1], a[2]);
                move(1, 2);
                paczka = pack(a[0], a[1], a[2]);
                if(checked.count(paczka) == 0){
                        checked.insert(paczka);
                        solution[a[0]] = std::min(solution[a[0]], prio);
                        solution[a[1]] = std::min(solution[a[1]], prio);
                        solution[a[2]] = std::min(solution[a[2]], prio);
                        qu.push(std::pair<int, long long>(prio * -1, paczka));
                }

                paczka = give.second;
                unpack(paczka, a[0], a[1], a[2]);
                move(2, 1);
                paczka = pack(a[0], a[1], a[2]);
                if(checked.count(paczka) == 0){
                        checked.insert(paczka);
                        solution[a[0]] = std::min(solution[a[0]], prio);
                        solution[a[1]] = std::min(solution[a[1]], prio);
                        solution[a[2]] = std::min(solution[a[2]], prio);
                        qu.push(std::pair<int, long long>(prio * -1, paczka));
                }

        }

        for(int i = 0; i < n; i++)
                std::cout << (solution[i] == INT32_MAX ? -1 : solution[i]) << " ";
        std::cout << "\n";

        return 0;
}