【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 = ;
 int M[maxn][maxn];
 bool reach[maxn][maxn];
 bool visit[maxn][maxn][maxn][maxn];
 int dir[][] = {
     -,, ,, ,-, ,
 };
 int gx, gy, bx, by, hx, hy;
 int n, m;
 int ans;

 bool judge(int x, int y) {
     return x< || x>=n || y< || 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, , ) {
             x = p.fir + dir[i][];
             y = p.sec + dir[i][];
             if (judge(x, y) || M[x][y]!= || 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\n", 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, ), 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== && nd.hy== && nd.bx== && nd.by==) {
                 puts("here");
             }
         #endif
         rep(i, , ) {
             d.hx = nd.hx + dir[i][];
             d.hy = nd.hy + dir[i][];
             if (judge(d.hx, d.hy) || M[d.hx][d.hy]==)
                 continue;

             // check whether is box
             if (d.hx==nd.bx && d.hy==nd.by) {
                 d.bx = nd.bx + dir[i][];
                 d.by = nd.by + dir[i][];
                 if (judge(d.bx, d.by) || M[d.bx][d.by]==)
                     continue;
                 d.bn = nd.bn + ;
             } 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== && d.hy== && d.bx== && d.by==) {
                     puts("there");
                 }
             #endif
             Q.push(d);
         }
     }

     return INT_MAX;
 }

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

     ans = INT_MAX;

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

     ans = ans==INT_MAX ? -:ans;
     printf("%d\n", 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, , n) {
             rep(j, , m) {
                 scanf("%d", &M[i][j]);
                 if (M[i][j] == ) {
                     bx = i;
                     by = j;
                 } else if (M[i][j] == ) {
                     gx = i;
                     gy = j;
                     M[i][j] = ;
                 } else if (M[i][j] == ) {
                     hx = i;
                     hy = j;
                     M[i][j] = ;
                 }
             }
         }

         solve();
     }

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

     return ;
 }