HDOJ-1242 Rescue（广搜，剪枝）

Rescue

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 17182    Accepted Submission(s): 6209

Problem Description

Angel was caught by the MOLIGPY! He was put in prison by Moligpy. The prison is described as a N * M (N, M <= 200) matrix. There are WALLs, ROADs, and GUARDs in the prison.

Angel's friends want to save Angel. Their task is: approach Angel. We assume that "approach Angel" is to get to the position where Angel stays. When there's a guard in the grid, we must kill him (or her?) to move into the grid. We assume that we moving up, down, right, left takes us 1 unit time, and killing a guard takes 1 unit time, too. And we are strong enough to kill all the guards.

You have to calculate the minimal time to approach Angel. (We can move only UP, DOWN, LEFT and RIGHT, to the neighbor grid within bound, of course.)

 

Input

First line contains two integers stand for N and M.

Then N lines follows, every line has M characters. "." stands for road, "a" stands for Angel, and "r" stands for each of Angel's friend. 

Process to the end of the file.

 

Output

For each test case, your program should output a single integer, standing for the minimal time needed. If such a number does no exist, you should output a line containing "Poor ANGEL has to stay in the prison all his life." 

 

Sample Input

  
  

   
   7 8
#.#####.
#.a#..r.
#..#x...
..#..#.#
#...##..
.#......
........
  
  

 

Sample Output

  
  

   
   13
  
  

 

解题思路：

多组数据，已知起点与终点，求最短路径。这是一道很常规的广搜题目，可以利用队列存储，遍历四个方向，在遇到怪兽的时候多一个操作，最终找到最短路径。但是却在提交的时候WA了很多次。。。有些地方是很坑的，因为要找的是最短路径，所以一个点就会可能经过多次，若距离缩短就将这个点刷新，如果距离不能缩短就不能再将这个点放入队列，否则会内存超限。看讨论上有很多人说遍历的方向顺序会影响结果，可能本质也是因为没有考虑到距离的刷新，结果换了方向之后勉强水过。。。总之，这是一道大水题，但是还是要思路清晰缜密一点，多想几组样例，慢慢调试A掉，选择一个最简单的方式去解决WA收获很少，看别人的Discuss自己就先乱了方向，最后得不到什么的。

#include <iostream>
#include <queue>
using namespace std;
const int INF=100000000;
char maze[210][210];
typedef pair<int ,int> p;
int n,m,stime;
int sx,sy;//初始位置
int gx,gy;//目标位置
int d[210][210];//保存距离，最初设置为INF
int dx[4]={0,1,0,-1};
int dy[4]={1,0,-1,0};
int bfs();
int main()
{
    while(cin>>n>>m)
    {
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=m;j++)
            {
                cin>>maze[i][j];
                d[i][j]=INF;
                if(maze[i][j]=='r')
                {
                    sx=i;sy=j;
                    d[i][j]=0;//起点距离设置为0
                }
                if(maze[i][j]=='a')
                {
                    gx=i;gy=j;
                }
            }
        }
        stime=0;
        stime=bfs();
        if(stime!=INF)//若走不到终点，距离会始终是d[gx][gy]=INF
            cout<<stime<<endl;
        else
            cout<<"Poor ANGEL has to stay in the prison all his life."<<endl;
    }
    return 0;
}
int bfs()
{
    queue<p> que;
    que.push(p(sx,sy));
    while(que.size())
    {
        p p1=que.front();
        que.pop();
        if(p1.first==gx&&p1.second==gy)//剪枝，到重点时一定已经是最短距离
            break;
        for(int i=0;i<4;i++)
        {
            int nx=p1.first+dx[i];
            int ny=p1.second+dy[i];
            if(nx>0&&nx<=n&&ny>0&&ny<=m&&maze[nx][ny]!='#')
            {
                int dis=d[p1.first][p1.second]+1;
                if(maze[nx][ny]=='x')
                    dis++;
                if(dis<d[nx][ny])//究竟能不能刷新，放入队列要慎重
                {
                    d[nx][ny]=dis;
                    que.push(p(nx,ny));
                }
                else
                    continue;
            }
        }
    }
    return d[gx][gy];//返回距离
}