胜利大逃亡

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

using namespace std;

const int N = 60;

int dx[] = {0, -1, 0, 1, 0, 0}, dy[] = {-1, 0, 1, 0, 0, 0}, dz[] = {0, 0, 0, 0, 1, -1};

struct node {
    int x, y, z;
    int s;
};

int k;
int a, b, c, t;
int g[N][N][N];
bool st[N][N][N];
bool flag;

void bfs() {
    queue<node> q;

    node One, next;
    One.x = One.y = One.z =  One.s = 0;
    q.push(One);

    while (q.size()) {
        auto T = q.front();
        q.pop();

        if (T.s > t)
            return;

        if (T.x == a - 1 && T.y == b - 1 && T.z == c - 1) {
            flag = true;
            printf("%d\n", T.s);
            return;
        }

        for (int i = 0; i < 6; i ++ ) {

            next.x = T.x + dx[i], next.y = T.y + dy[i], next.z = T.z + dz[i];

            if (next.x >= 0 && next.x < a && next.y >= 0 && next.y < b && next.z >= 0 && next.z < c && !st[next.x][next.y][next.z]
                    && !g[next.x][next.y][next.z]) {
                st[next.x][next.y][next.z] = true;
                next.s = T.s + 1;
                q.push(next);
            }
        }
    }
}

int main() {
    scanf("%d", &k);

    while (k -- ) {
        memset(st, false, sizeof st);
        flag = false;

        scanf("%d%d%d%d", &a, &b, &c, &t);

        for (int i = 0; i < a; i ++ )

            for (int j = 0; j < b; j ++ )

                for (int p = 0; p < c; p ++ )

                    scanf("%d", &g[i][j][p]);

        bfs();

        if (!flag)
            printf("-1\n");
    }

    return 0;
}

非常可乐

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

using namespace std;

const int N = 110;

struct node {
    int s, n, m;
    int step;
};

int s, n, m;
bool st[N][N][N];
int ans;

int bfs() {
    if (s % 2 == 1)
        return -1;

    queue<node> q;
    node One, next;
    One.s = s, One.n = One.m = One.step = 0;
    st[s][0][0] = true;
    q.push(One);

    while (q.size()) {
        auto t = q.front();
        q.pop();

        if ((t.s == t.m && t.s == s / 2) || (t.s == t.n && t.s == s / 2) || (t.m == t.n && t.m == s / 2))
            return t.step;

        // s -> n
        if (t.s && t.n < n) {
            // s 倒完
            if ((t.s + t.n) <= n) {
                next.s = 0;
                next.n = t.s + t.n;
                next.m = t.m;
            }

            // s 没倒完
            if ((t.s + t.n) > n) {
                next.s = t.s - (n - t.n);
                next.n = n;
                next.m = t.m;
            }

            if (!st[next.s][next.n][next.m]) {
                st[next.s][next.n][next.m] = true;
                next.step = t.step + 1;
                q.push(next);
            }
        }

        // s -> m
        if (t.s && t.m < m) {
            // s 倒完
            if ((t.s + t.m) <= m) {
                next.s = 0;
                next.n = t.n;
                next.m = t.m + t.s;
            }

            // s 没倒完
            if ((t.s + t.m) > m) {
                next.s = t.s - (m - t.m);
                next.n = t.n;
                next.m = m;
            }

            if (!st[next.s][next.n][next.m]) {
                st[next.s][next.n][next.m] = true;
                next.step = t.step + 1;
                q.push(next);
            }
        }

        // n -> m
        if (t.n && t.m < m) {
            // n 倒完
            if ((t.n + t.m) <= m) {
                next.s = t.s;
                next.n = 0;
                next.m = t.m + t.n;
            }

            // n 没倒完
            if ((t.n + t.m) > m) {
                next.s = t.s;
                next.n = t.n - (m - t.m);
                next.m = m;
            }

            if (!st[next.s][next.n][next.m]) {
                st[next.s][next.n][next.m] = true;
                next.step = t.step + 1;
                q.push(next);
            }
        }

        // n -> s
        if (t.n && t.s < s) {
            // n 倒完
            if ((t.n + t.s) <= s) {
                next.s = t.s + t.n;
                next.n = 0;
                next.m = t.m;
            }

            // n 没倒完
            if ((t.n + t.s) > s) {
                next.s = s;
                next.n = n - (s - t.s);
                next.m = t.m;
            }

            if (!st[next.s][next.n][next.m]) {
                st[next.s][next.n][next.m] = true;
                next.step = t.step + 1;
                q.push(next);
            }
        }

        // m -> s
        if (t.m && t.s < s) {
            // m 倒完
            if ((t.m + t.s) <= s) {
                next.s = t.s + t.m;
                next.n = t.n;
                next.m = 0;
            }

            // m 没倒完
            if ((t.m + t.s) > s) {
                next.s = s;
                next.n = n;
                next.m = t.m - (s - t.s);
            }

            if (!st[next.s][next.n][next.m]) {
                st[next.s][next.n][next.m] = true;
                next.step = t.step + 1;
                q.push(next);
            }
        }

        // m -> n
        if (t.m && t.n < n) {
            // m 倒完
            if ((t.m + t.n) <= n) {
                next.s = t.s;
                next.n = t.m + t.n;
                next.m = 0;
            }

            // m 没倒完
            if ((t.m + t.n) > n) {
                next.s = t.s;
                next.n = n;
                next.m = t.m - (n - t.n);
            }

            if (!st[next.s][next.n][next.m]) {
                st[next.s][next.n][next.m] = true;
                next.step = t.step + 1;
                q.push(next);
            }
        }
    }

    return -1;
}

int main() {
    while (cin >> s >> n >> m) {
        if (s == 0 && n == 0 && m == 0)
            break;

        memset(st, false, sizeof st);

        ans = bfs();

        if (ans <= 0)
            cout << "NO" << endl;
        else
            cout << ans << endl;
    }

    return 0;
}