【HDOJ】1254 推箱子

来一发搜索。数据量比较小，这么玩儿都能ac。搞个优先队列。
先扫描从起点可以到达箱子的上下左右中哪些位置，并针对这些位置进行bfs。
所谓推，就是箱子和人同向移动一个单位。bfs的时候注意一些限制条件就好了。

/* 1254 */
#include <iostream>
#include <string>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#include <deque>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <ctime>
#include <cstring>
#include <climits>
#include <cctype>
#include <cassert>
#include <functional>
#include <iterator>
#include <iomanip>
using namespace std;
//#pragma comment(linker,"/STACK:102400000,1024000")

#define sti                set<int>
#define stpii            set<pair<int, int> >
#define mpii            map<int,int>
#define vi                vector<int>
#define pii                pair<int,int>
#define vpii            vector<pair<int,int> >
#define rep(i, a, n)     for (int i=a;i<n;++i)
#define per(i, a, n)     for (int i=n-1;i>=a;--i)
#define clr                clear
#define pb                 push_back
#define mp                 make_pair
#define fir                first
#define sec                second
#define all(x)             (x).begin(),(x).end()
#define SZ(x)             ((int)(x).size())
#define lson            l, mid, rt<<1
#define rson            mid+1, r, rt<<1|1

const int maxn = 10;
int M[maxn][maxn];
bool reach[maxn][maxn];
bool visit[maxn][maxn][maxn][maxn];
int dir[4][2] = {
    -1,0, 1,0, 0,-1, 0,1
};
int gx, gy, bx, by, hx, hy;
int n, m;
int ans;

bool judge(int x, int y) {
    return x<0 || x>=n || y<0 || y>=m;
}

void bfs_human() {
    queue<pii> Q;
    pii p;
    int x, y;

    memset(reach, false, sizeof(reach));
    reach[hx][hy] = true;
    Q.push(mp(hx, hy));

    while (!Q.empty()) {
        p = Q.front();
        Q.pop();
        rep(i, 0, 4) {
            x = p.fir + dir[i][0];
            y = p.sec + dir[i][1];
            if (judge(x, y) || M[x][y]!=0 || reach[x][y])
                continue;
            reach[x][y] = true;
            Q.push(mp(x, y));
        }
    }
}

typedef struct node_t {
    int hx, hy;
    int bx, by;
    int bn;

    node_t() {}

    node_t(int hx, int hy, int bx, int by, int bn):
        hx(hx), hy(hy), bx(bx), by(by), bn(bn) {}

    friend bool operator< (const node_t& a, const node_t& b) {
        return a.bn > b.bn;
    }

    void print() {
        printf("hx=%d, hy=%d, bx=%d, by=%d, bn=%d
", hx,hy,bx,by,bn);
    }

} node_t;

// #define DEBUG
int bfs(int hx, int hy) {
    priority_queue<node_t> Q;
    node_t d(hx, hy, bx, by, 0), nd;

    memset(visit, false, sizeof(visit));
    visit[bx][by][hx][hy] = true;
    Q.push(d);

    while (!Q.empty()) {
        nd = Q.top();
        Q.pop();
        #ifdef DEBUG
            nd.print();
            if (nd.hx==2 && nd.hy==1 && nd.bx==3 && nd.by==1) {
                puts("here");
            }
        #endif
        rep(i, 0, 4) {
            d.hx = nd.hx + dir[i][0];
            d.hy = nd.hy + dir[i][1];
            if (judge(d.hx, d.hy) || M[d.hx][d.hy]==1)
                continue;

            // check whether is box
            if (d.hx==nd.bx && d.hy==nd.by) {
                d.bx = nd.bx + dir[i][0];
                d.by = nd.by + dir[i][1];
                if (judge(d.bx, d.by) || M[d.bx][d.by]==1)
                    continue;
                d.bn = nd.bn + 1;
            } else {
                d.bx = nd.bx;
                d.by = nd.by;
                d.bn = nd.bn;
            }

            if (visit[d.bx][d.by][d.hx][d.hy])
                continue;

            visit[d.bx][d.by][d.hx][d.hy] = true;
            if (d.bx==gx && d.by==gy)
                return d.bn;

            #ifdef DEBUG
                nd.print();
                if (d.hx==4 && d.hy==1 && d.bx==3 && d.by==1) {
                    puts("there");
                }
            #endif
            Q.push(d);
        }
    }

    return INT_MAX;
}

void solve() {
    int x, y, tmp;

    ans = INT_MAX;

    bfs_human();
    rep(i, 0, 4) {
        x = bx + dir[i][0];
        y = by + dir[i][1];
        if (judge(x, y) || M[x][y]==1 || !reach[x][y])
            continue;
        tmp = bfs(x, y);
        ans = min(tmp, ans);
    }

    ans = ans==INT_MAX ? -1:ans;
    printf("%d
", ans);
}

int main() {
    ios::sync_with_stdio(false);
    #ifndef ONLINE_JUDGE
        freopen("data.in", "r", stdin);
        freopen("data.out", "w", stdout);
    #endif

    int t;

    scanf("%d", &t);
    while (t--) {
        scanf("%d %d", &n, &m);
        rep(i, 0, n) {
            rep(j, 0, m) {
                scanf("%d", &M[i][j]);
                if (M[i][j] == 2) {
                    bx = i;
                    by = j;
                } else if (M[i][j] == 3) {
                    gx = i;
                    gy = j;
                    M[i][j] = 0;
                } else if (M[i][j] == 4) {
                    hx = i;
                    hy = j;
                    M[i][j] = 0;
                }
            }
        }

        solve();
    }

    #ifndef ONLINE_JUDGE
        printf("time = %d.
", (int)clock());
    #endif

    return 0;
}