問題描述

題目連結：http://acm.hdu.edu.cn/showproblem.php?pid=1254
推箱子是一個很經典的遊戲.今天我們來玩一個簡單版本.在一個M*N的房間裡有一個箱子和一個搬運工,搬運工的工作就是把箱子推到指定的位置,注意,搬運工只能推箱子而不能拉箱子,因此如果箱子被推到一個角上(如圖2)那麼箱子就不能再被移動了,如果箱子被推到一面牆上,那麼箱子只能沿著牆移動.

現在給定房間的結構,箱子的位置,搬運工的位置和箱子要被推去的位置,請你計算出搬運工至少要推動箱子多少格.

輸入格式
輸入資料的第一行是一個整數T(1<=T<=20),代表測試資料的數量.
然後是T組測試資料,每組測試資料的第一行是兩個正整數M,N(2<=M,N<=7),代表房間的大小.
然後是一個M行N列的矩陣,代表房間的佈局,其中0代表空的地板,1代表牆,2代表箱子的起始位置,3代表箱子要被推去的位置,4代表搬運工的起始位置.
輸出格式
對於每組測試資料,輸出搬運工最少需要推動箱子多少格才能幫箱子推到指定位置,如果不能推到指定位置則輸出-1.

樣例輸入
1
5 5
0 3 0 0 0
1 0 1 4 0
0 0 1 0 0
1 0 2 0 0
0 0 0 0 0

樣例輸出
4

思路

求最短時間一般用的是bfs。但這道題用普通的bfs會WA，因為要求的最短路是推動箱子的最小步數，而普通的bfs是搬運工移動的最小次數，而移動的次數少不一定能代表推動箱子次數少，例如下面這組資料：
1
3 5
1 1 4 0 0
0 2 0 0 0
0 3 0 0 0
若用普通的bfs執行這組資料，得到的結果是5，而用優先佇列+bfs執行結果是3，因為此時推動箱子次數少，但搬運工走的步數要多（若想要只推動3次箱子則必須繞幾個彎才能達到終點）。故普通的bfs會WA。

注意事項

雖然優先佇列可以用C++的STL模板庫裡的priority_queue，如下：

priority_queue<node> w; //這是元素大的排前面，若想要元素小的排前面則要用priority_queue<node,vector<int>,greater<int> > w;

但是需要過載一個<，並注意在前面加上friend，如下：

friend inline bool operator < (node a,node b) {
    return a.t>b.t;   //注意符號不要寫反，是大於號
}

每次bfs完都要把佇列裡剩下的元素全部彈出，如下：

while(!w.empty())   w.pop();

bfs函式

首先要用一個數組來記錄狀態。這裡由於人和箱子的位置都要記錄，所以應用一個四維陣列來記錄（其實由於n和m不超過7，二維陣列，十位表示橫座標，個位表示縱座標也是可以的）。
當人碰到箱子的時候箱子就向同樣的方向移動一次。
其他和普通的bfs是一樣的，就不詳細說了。
搜完所有狀態後若仍無解則返回-1。

程式碼

#include<stdio.h>
#include<cstring>
#include<queue>
using namespace std;
const int Size=13;
const int dx[] = {1,0,0,-1};
const int dy[] = {0,1,-1,0};
int map[Size][Size];
bool memory[Size][Size][Size][Size];    //判重陣列
int m,n,x1,y1,x2,y2,x3,y3;
struct node {       //節點
    int x,y;
    int bx,by;
    int t;
    friend inline bool operator < (node a,node b) {
        return a.t>b.t;
    }
};
priority_queue<node>w;
void push_queue(int x,int y,int bx,int by,int time) {
    node a;
    a.x=x,a.y=y,a.bx=bx,a.by=by,a.t=time;
    w.push(a);
    memory[x][y][bx][by]=true;
}
int read() {            //快速讀入函式
    int x=0,f=1;
    char ch=getchar();
    while(ch<'0' || ch>'9') {
        if(ch=='-')    f=-1;
        ch=getchar();
    }
    while(ch>='0' && ch<='9') {
        x=10*x+ch-'0';
        ch=getchar();
    }
    return x*f;
}
void init() {           //初始化
    memset(memory,0,sizeof(memory));
    m=read(),n=read();
    for(int i=1; i<=m; i++) {
        for(int j=1; j<=n; j++) {
            map[i][j]=read();
            switch(map[i][j]) {
                case 2: x3=i;y3=j;break;
                case 3: x2=i;y2=j;break;
                case 4: x1=i;y1=j;break;
                default:break;
            }
        }
    }
    while(!w.empty())   w.pop();    //將佇列裡剩下的元素彈出佇列
    push_queue(x1,y1,x3,y3,0); 
}
inline bool judge(int x,int y) {    //判斷(x,y)滿不滿足入隊要求
    return (x>=1 && y>=1 && x<=m && y<=n && map[x][y]!=1);
}
int bfs() {
    node now,nxt;
    int nx,ny,bx,by,nt;
    while(!w.empty()) {
        now=w.top();
        w.pop();
        if(map[now.bx][now.by]==3)  return now.t;
        for(int i=0; i<4; i++) {
            nx=now.x+dx[i],ny=now.y+dy[i];
            bx=now.bx,by=now.by;
            nt=now.t;
            if(judge(nx,ny) && (!memory[nx][ny][bx][by])) {
                if(nx==bx && ny==by) {
                    bx+=dx[i],by+=dy[i],nt++;
                    if(!judge(bx,by)||memory[nx][ny][bx][by])continue;
                    push_queue(nx,ny,bx,by,nt);
                } else {
                    push_queue(nx,ny,bx,by,nt);
                }
            }
        }
    }
    return -1;
}
int main() {
    int t=read(),out;
    while(t--) {
        init();
        printf("%d\n",bfs());
    }
    return 0;
}