Pushing Boxes（广度优先搜索）

题目传送门

首先说明我这个代码和lyd的有点不同：可能更加复杂

　既然要求以箱子步数为第一关键字，人的步数为第二关键字，那么我们可以想先找到箱子的最短路径。但单单找到箱子的最短路肯定不行啊，因为有时候不能被推动，怎样确定一条既满足最短又满足可行的箱子路径呢，其实这就是一种有限制的BFS。

　对于箱子：

　　设现在的位置为x,y,扩展方向为dx,dy，将要到达的下一个位置为x+dx,y+dy

　check它是否可行：

1.不越界。

2.之前没有走过。

3.不能走到“#”上。

4.人能够从当前站立的位置到达(x-dx,y-dy)。

诶，对了，第4个条件实际上就是对于人的bfs。

---

　　因此，这就是一个双重bfs。（数据范围r,c<=20可行！）

　　那么对于人的bfs,有什么限制条件：当然最重要的不能走到箱子现在的位置（x,y）上

　　还有记录路径，每次回溯和逆推。

　　嗯，具体细节看代码吧（不想打字了）

//Pushing Boxes -POJ1475
//最长代码 祭 AC  329ms
//开始没有数组清零WA
//然后数组开大了，TLE
#include<cstring>
#include<algorithm>
#include<iostream>
#include<cstdio>
#include<queue>
#define de system("pause");
#define re register int
using namespace std;
int r,c,ans,ansx,ansy;
char s[][];
int per[],box[];
int dx[]={-,,,};
int dy[]={,,-,};
char ren[]={'n','s','w','e'};
char xiang[]={'N','S','W','E'};
bool bz[][],flag[][];
struct node{
    int x,y,step;
    int man[];
    node(int xx,int yy,int stepp,int mx,int my)
    {
        x=xx,y=yy,step=stepp;
        man[]=mx,man[]=my;
    }
};
struct node2{
    int x,y;
    node2(int xx,int yy)
    {
        x=xx;
        y=yy;
    }
};
queue<node> q;
queue<node2> p;
struct hp{
    int px,py,d;
    int cnt;
    int path[];
}fix[][],walk[][];
//fix主要记录箱子的路径，walk主要记录人的路径。
inline bool bfs(int bx,int by,int aimx,int aimy,int nowx,int nowy)
{
    memset(flag,,sizeof flag);
    memset(walk,,sizeof walk);
    while(p.size()) p.pop();
    p.push(node2(nowx,nowy));
    if(nowx==aimx&&nowy==aimy) return ;
    flag[nowx][nowy]=;
    while(!p.empty())
    {
        node2 now=p.front();
        int x=now.x,y=now.y;
        p.pop();
        for(re i=;i<=;++i)
        {
            int cx=x+dx[i],cy=y+dy[i];
            if(cx<||cx>r||cy<||cy>c)continue;
            if(flag[cx][cy])continue;
            if(s[cx][cy]=='#')continue;
            if(cx==bx&&cy==by)continue;
            p.push(node2(cx,cy));
            flag[cx][cy]=;
            walk[cx][cy].px=x;
            walk[cx][cy].py=y;
            walk[cx][cy].d=i;
            if(cx==aimx&&cy==aimy)
            {
                return ;
            }
        }
    }
    return ;
}
inline bool check(int x,int t1,int y,int t2,int standx,int standy)
{
    if(x+t1<||x+t1>r||y+t2<||y+t2>c)return ;
    if(bz[x+t1][y+t2]) return ;
    if(s[x+t1][y+t2]=='#')return ;
    if(bfs(x,y,x-t1,y-t2,standx,standy))//如果人能够移动
    {
        int tx=x-t1,ty=y-t2;//从目标回溯到初位置
        while(tx!=standx||ty!=standy)
        {
            hp temp=walk[tx][ty];
            fix[x+t1][y+t2].path[++fix[x+t1][y+t2].cnt]=walk[tx][ty].d;
            tx=temp.px;
            ty=temp.py;
        }//在这里顺便就把这一次转移路径记录下来
        return ;
    }
    return ;
}
inline void Bfs()
{
    while(!q.empty())
    {
        node now=q.front();
        int x=now.x,y=now.y,step=now.step;
        int man_x=now.man[],man_y=now.man[];
        q.pop();
        for(re i=;i<=;++i)
        {
            int cx=x+dx[i],cy=y+dy[i];
            if(check(x,dx[i],y,dy[i],man_x,man_y))
            {
                q.push(node(cx,cy,step+,x,y));
                bz[cx][cy]=;
                fix[cx][cy].px=x,fix[cx][cy].py=y;
                fix[cx][cy].d=i;
                if(s[cx][cy]=='T')
                {
                    if(step+<ans)
                    {
                        ans=step+;
                        ansx=cx,ansy=cy;
                    }
                }
            }
        }
    }
}

char shuchu[];
int rt=;
inline void print()
{
    int num=;
    int prx=ansx;
    int pry=ansy;
    int tt=;
    while((prx!=box[])||(pry!=box[]))
    {
        hp ne=fix[prx][pry];
        shuchu[++num]=xiang[ne.d];
        for(re i=;i<=ne.cnt;++i)
        {
            shuchu[++num]=ren[ne.path[i]];
        }
        prx=ne.px;
        pry=ne.py;
    }
    printf("Maze #%d\n",++rt);
    for(re i=num;i>=;--i) cout<<shuchu[i];
    puts("");
}
int main()
{
    while()
    {
        while(q.size())q.pop();
        memset(bz,,sizeof bz);
//        memset(shuchu,0,sizeof shuchu);
        memset(fix,,sizeof fix);
//        memset(walk,0,sizeof walk);
        ans=1e6;
        scanf("%d%d",&r,&c);
        if(r==&&c==)break;
        for(re i=;i<=r;++i){
            scanf("%s",s[i]+);
            for(re j=;j<=c;++j){
                if(s[i][j]=='B')box[]=i,box[]=j,bz[i][j]=;
                if(s[i][j]=='S')per[]=i,per[]=j;
            }
        }
        q.push(node(box[],box[],,per[],per[]));
        Bfs();
        if(ans==1e6)
        {
            printf("Maze #%d\n",++rt);
            puts("Impossible.");
        }
        else print();
        puts("");
    }
    return ;
}

Add/

1.关于POJ的special judge可能有点毒瘤，所以建议按照'N','S','W','E'的方向进行搜索。

2.数组不要开大了。

3.输出两个换行......