Escape（反思与总结）

题目描述：

BH is in a maze,the maze is a matrix,he wants to escape!

Input：

The input consists of multiple test cases.
For each case,the first line contains 2 integers N,M( 1 <= N, M <= 100 ).
Each of the following N lines contain M characters. Each character means a cell of the map.
Here is the definition for chracter.
 
For a character in the map:
'S':BH's start place,only one in the map.
'E':the goal cell,only one in the map.
'.':empty cell.
'#':obstacle cell.
'A':accelerated rune.
 
BH can move to 4 directions(up,down,left,right) in each step.It cost 2 seconds without accelerated rune.When he get accelerated rune,moving one step only cost 1 second.The buff lasts 5 seconds,and the time doesn't stack when you get another accelerated rune.(that means in anytime BH gets an accelerated rune,the buff time become 5 seconds).

Output：

The minimum time BH get to the goal cell,if he can't,print "Please help BH!".

理解：

总体来说，这个游戏是要玩最短路hhh，但是要判断有无加速向，最开始只想着用二维数组来记录从起点到每一个点的最短路径（距离），然后用queue正常做，只不过在结构体中多用一个buff元素来判断是否有吃到加速，然后每一次 if(que.front().buff > 0) temp.buff = que.front().buff-1;但由于经过同一点时，可能会有不同的路径，并且也可能有更短的出现，在标记buff和最短路难以权衡。

于是在某大大怪大牛的提醒下，在结构体中用step来记录最短路（这样就可以更新相同点的最短路），然后就是本题最核心也最有意思的地方了，用优先队列处理数据~。。由于同一点都可能有不同的路径，而不同的路径就会有可能有的路径有buff，有的没有（也可以理解为，同一个点先去捡一个buff，大致捡了buff的路径通常会最短？这个有待我思考。）于是用一个三维vis来记录同一个点出现的不同能量值，如果没标记过，就要标记起来并且压入的队列。

代码如下：

#include <bits/stdc++.h>
using namespace std;
const int maxn = 105;
const int INF = 0x3f3f3f3f;
bool vis[maxn][maxn][10];
int way[4][2] = { {0,1}, {0,-1}, {1,0}, {-1,0} };
int mins;
struct node{
    int x,y,step,buff;
    friend bool operator < (const node a, const node b)
    {
        if(a.step == b.step)    return a.buff < b.buff;
        return a.step > b.step;
    }
};
priority_queue<node> que;
int n, m, sx, sy, ex, ey;
char a[maxn][maxn];
void bfs(){
    node temp, next, first;
    vis[sx][sy][0] = true;
    first.x = sx, first.y = sy, first.step = 0, first.buff = 0;
    que.push(first);
    while(!que.empty()){
        temp = que.top();
        que.pop();
        if(temp.x == ex && temp.y == ey){
            mins = min(mins, temp.step);
            break;
        }
        else
        {
            for(int i = 0; i < 4; i++)
            {
                int dx = temp.x+way[i][0];
                int dy = temp.y+way[i][1];
                if(dx<0 || dx>=n || dy<0 || dy>=m || a[dx][dy] == '#')    continue;
                if(temp.buff > 0){
                    next.buff = temp.buff - 1;
                    next.step = temp.step + 1;
                }else{
                    next.buff = 0;
                    next.step = temp.step + 2;
                }
                if(a[dx][dy] == 'A')
                    next.buff = 5;
                if(vis[dx][dy][next.buff])
                    continue;
                vis[dx][dy][next.buff] = true;
                next.x = dx, next.y = dy;
                que.push(next);
            }
        }
    }
    return ;
}

int main()
{
    while(cin >> n >> m){
        mins = INF;
        memset(vis, false, sizeof(vis));
        memset(a, 0, sizeof(a));
        while(!que.empty())    que.pop();
        for(int i = 0; i < n; i++)
            for(int j = 0; j < m; j++)
                cin >> a[i][j];
        for(int i = 0; i < n; i++)
            for(int j = 0; j < m; j++){
                if(a[i][j] == 'S')
                    sx = i, sy = j;
                else if(a[i][j] == 'E')
                    ex = i, ey = j;
            }
        bfs();
        if(mins == INF)
            cout << "Please help BH!" << "
";
        else
            cout << mins << "
";
    }
    return 0;
 }