hdu 5012 Dice(西安网络赛F题,BFS)

BFS+记忆化搜索。。

网赛的时候，竟然一开始没发现这道水题。后来TYQ做的时候用了很久去判断一开始就是INF的情况，其实就这道题的数据而言，根本不需要。。。

后来在hdu上交的时候，限制搜索步长为3，竟然都AC了。。。

不过，就是这么水的数据，我一开始误打的DFS竟然WA了！！

代码先注释了，等哪天空了来对拍一下 = = Orz。。

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <vector>
#include <queue>
#include <stack>
#include <cassert>
#include <algorithm>
#include <cmath>
#include <set>
#include <map>
#include <limits>

using namespace std;

#define MIN(a, b) ((a) < (b) ? (a) : (b))
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define F(i, n) for (int (i)=0;(i)<(n);++(i))
#define REP(i, s, t) for(int (i)=(s);(i)<=(t);++(i))
#define UREP(i, s, t) for(int (i)=(s);(i)>=(t);--(i))
#define REPOK(i, s, t, o) for(int (i)=(s);(i)<=(t) && (o);++(i))
#define MEM0(addr, size) memset(addr, 0, size)
#define LBIT(x) x&-x

#define PI 3.1415926535897932384626433832795
#define HALF_PI 1.5707963267948966192313216916398

#define MAXN 100
#define MAXM 10000
#define MOD 10000007

typedef long long LL;

const double maxdouble = numeric_limits<double>::max();
const double eps = 1e-10;
const int INF = 0x7FFFFFFF;

#define DEBUG

map<int, int> _map;
int buf[MAXN];
int ans = INF;

struct Dice{
    int top;
    int bot;
    int lef;
    int rig;
    int fro;
    int bac;
    bool read_in() {
        return scanf("%d %d %d %d %d %d",&top, &bot, &lef, &rig, &fro, &bac) != EOF;
    }
    int make_num() {
        int ret = top;
        ret = ret*10 + bot;
        ret = ret*10 + lef;
        ret = ret*10 + rig;
        ret = ret*10 + fro;
        ret = ret*10 + bac;
        return ret;
    }
    bool operator == (Dice & b) {
        return top == b.top && bot == b.bot && lef == b.lef && rig == b.rig
            && fro == b.fro && bac == b.bac;
    }
};

Dice A, B;
int cnt[4];

Dice left_rotation(const Dice & d) {
    Dice ret = d;
    int tmp = ret.top;
    ret.top = ret.rig;
    ret.rig = ret.bot;
    ret.bot = ret.lef;
    ret.lef = tmp;
    return ret;
}

Dice right_rotation(const Dice & d) {
    Dice ret = d;
    int tmp = ret.top;
    ret.top = ret.lef;
    ret.lef = ret.bot;
    ret.bot = ret.rig;
    ret.rig = tmp;
    return ret;
}

Dice front_rotation(const Dice & d) {
    Dice ret = d;
    int tmp = ret.top;
    ret.top = ret.bac;
    ret.bac = ret.bot;
    ret.bot = ret.fro;
    ret.fro = tmp;
    return ret;
}

Dice back_rotation(const Dice & d) {
    Dice ret = d;
    int tmp = ret.top;
    ret.top = ret.fro;
    ret.fro = ret.bot;
    ret.bot = ret.bac;
    ret.bac = tmp;
    return ret;
}
/*
int dfs(Dice & d, int step) {
    if (d == A) {
        ans = min(ans, step);
        return 0;
    }
    Dice tmp;
    int now = d.make_num(), num, val = INF;
    if (_map.find(now) != _map.end())
        return _map[now];
    // left
    if (cnt[0] < 4) {
            tmp = left_rotation(d);
            num = tmp.make_num();
            if (_map.find(num) != _map.end()) {
                int n = _map[num];
                if (n != INF)
                    val = min(val, n);
            } else {
                ++cnt[0];
                val = min(val, dfs(tmp, step+1));
                --cnt[0];
            }
    }
    // right
    if (cnt[1] < 4) {
            tmp = right_rotation(d);
            num = tmp.make_num();
            if (_map.find(num) != _map.end()) {
                int n = _map[num];
                if (n != INF)
                    val = min(val, n);
            } else {
                ++cnt[1];
                val = min(val, dfs(tmp, step+1));
                --cnt[1];
            }
    }
    // front
    if (cnt[2] < 4) {
            tmp = front_rotation(d);
            num = tmp.make_num();
            if (_map.find(num) != _map.end()) {
                int n = _map[num];
                if (n != INF)
                    val = min(val, n);
            } else {
                ++cnt[2];
                val = min(val, dfs(tmp, step+1));
                --cnt[2];
            }
    }
    // bottom
    if (cnt[3] < 4) {
            tmp = back_rotation(d);
            num = tmp.make_num();
            if (_map.find(num) != _map.end()) {
                int n = _map[num];
                if (n != INF)
                    val = min(val, n);
            } else {
                ++cnt[3];
                val = min(val, dfs(tmp, step+1));
                --cnt[3];
            }
    }

    if (val == INF)
        _map[now] = INF;
    else {
        _map[now] = val+1;
        ans = min(ans, step+val+1);
    }
    return _map[now];
}*/

int main() {
    freopen("input.in", "r", stdin);

    while(A.read_in() && B.read_in()) {
        ans = INF;
        _map.clear();
         queue<Dice> q;
        //memset(cnt, 0, sizeof(cnt));
        //dfs(B, 0);
        q.push(B);
        _map[B.make_num()] = 0;

        while(q.empty() == false) {
            Dice fr = q.front();q.pop();
            int num = fr.make_num();
            int step = _map[num];
            if (fr == A) {
                ans = min(ans, step);
                break;
            }
            //cout << "front: " << num << " step: " << step <<  endl;
            if (step > 9)
                continue;
            Dice t;
            // left
            t = left_rotation(fr);
            num = t.make_num();
            if (_map.find(num) == _map.end()) {
                q.push(t);_map[num] = step+1;
            }

            // right
            t = right_rotation(fr);
            num = t.make_num();
            if (_map.find(num) == _map.end()) {
                q.push(t);_map[num] = step+1;
            }
            // front
            t = front_rotation(fr);
            num = t.make_num();
            if (_map.find(num) == _map.end()) {
                q.push(t);_map[t.make_num()] = step+1;
            }
            // back
            t = back_rotation(fr);
            num = t.make_num();
            if (_map.find(num) == _map.end()) {
                q.push(t);_map[t.make_num()] = step+1;
            }
        }

        if (ans == INF)
            printf("-1\n");
        else
            printf("%d\n", ans);
    }

    return 0;
}