团战可以输、提莫必须死

Description
为了一些你们不知道的原因,我们把LOL的地图抽象为一个n×m的矩阵
提莫积攒了k个蘑菇准备种到地图上去，因为提莫的背篓漏了，所以每一个提莫走过的地方都会被摆下一个蘑菇，两个蘑菇同时种在一个地方的话就会爆炸，所以一旦即将出现这种情况，提莫会直接传送回家，防止自己被炸死
之前的排位赛中因为乱种蘑菇提莫已经被骂了好多次了，所以这次提莫特地查资料对当前地图的各个位置种下蘑菇的价值做了统计，但是因为提莫行动比较笨拙，所以他每次只能移动到上下左右四个方向的格子中（如果该方向有格子的话
每次行走提莫会从四个方向挑选一个权值最大的方向，如果有最大的权值有多个，他会从这多个相同的最大权值之中找出没有走过并且按照上下左右的优先顺序挑选一个合适的方向走。如果最大权值都被走过了，他会心灰意冷的传送回家，此时直接输出"BOOM"
（提莫会顺手在他的起点顺手种一个蘑菇下去

Input
多组输入。
输入第一行包含地图大小n，m，蘑菇数量k。（1 <= n,m <= 100,1 <= k <= n*m)
接下来的n行每行有m个数（并且保证每个数的范围[1,1e5)
接下来两个整数x,y代表提莫的起点

Output
如果走到最后没有地方可以种蘑菇了，但蘑菇还没全部种完，输出"BOOM".
如果蘑菇在半途中种完了，输出提莫所处的坐标"Teemo: x y".

Sample
Input
3 3 3
1 2 3
4 5 6
7 8 9
2 2
3 3 5
1 2 3
4 5 6
7 8 9
2 2
Output
Teemo: 3 3
BOOM
题解：类似于一个bfs遍历模板题，但要注意的是这里找的最大值，本来理解错题意了，以为只是按照顺序走，然后和只进行了一条路径，后来看了看其他人的的代码，发现不是这样，因为max值可以有很多个，如果上下左右按照这个顺序其中一个不行了看下一个。
下面是第一遍错的时候的代码：

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<algorithm>
using namespace std;
int dx[]={-1,1,0,0};
int dy[]={0,0,-1,1};
int a[105][105];
int flag[105][105];
int num,n,m,k;
void BFS(int x,int y)
{
    flag[x][y]=1;
    num++;
    while(1)
    {
       int max=-1,i;
       for(i=0;i<=3;i++)
       {
         int tx=x+dx[i];
         int ty=y+dy[i];
         if(tx>=1&&tx<=n&&ty>=1&&ty<=m)
         {
            if(a[tx][ty]>max)
                max=a[tx][ty];
         }
       }
       for(i=0;i<=3;i++)
       {
           int tx=x+dx[i];
           int ty=y+dy[i];
           if(tx>=1&&tx<=n&&ty>=1&&ty<=m&&a[tx][ty]==max&&flag[tx][ty]==0)
           {
               flag[tx][ty]=1;
               num++;
               x=tx;
               y=ty;
               if(num==k)
               {
                    printf("Teemo: %d %d\n",x,y);
                    return;
               }
               break;
           }
       }
       if(i==4)
        {
            printf("BOOM\n");
            return;
        }
    }
    printf("BOOM\n");
    return ;
}
int main()
{
    int i,j;
    int x,y;
    while(cin>>n>>m>>k)
    {
        memset(flag,0,sizeof(flag));
         for(i=1;i<=n;i++)
         {
             for(j=1;j<=m;j++)
                 cin>>a[i][j];
         }
         cin>>x>>y;
         BFS(x,y);
         memset(a,0,sizeof(a));
         num=0;
    }
    return 0;
}

下面是AC代码：

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<algorithm>
#include<queue>
using namespace std;
int dx[]={-1,1,0,0};
int dy[]={0,0,-1,1};
int a[105][105];
int flag[105][105];
int num,n,m,k;
struct node
{
    int x,y;
    int ans;
}p,t;
void BFS(int x,int y)
{
    queue<node> q;
    t.x=x;
    t.y=y;
    t.ans=1;
    flag[t.x][t.y]=1;
    q.push(t);
    while(!q.empty())
    {
        t=q.front();
        q.pop();
       int max=-1,i;
       flag[t.x][t.y]=1;
       if(t.ans==k)
       {
           printf("Teemo: %d %d\n",t.x,t.y);
           return ;
       }
       for(i=0;i<=3;i++)
       {
         p.x=t.x+dx[i];
         p.y=t.y+dy[i];
         if(p.x>=1&&p.x<=n&&p.y>=1&&p.y<=m)
         {
            if(a[p.x][p.y]>max)
                max=a[p.x][p.y];
         }
       }
       for(i=0;i<=3;i++)
       {
           p.x=t.x+dx[i];
           p.y=t.y+dy[i];
           if(p.x>=1&&p.x<=n&&p.y>=1&&p.y<=m&&a[p.x][p.y]==max&&flag[p.x][p.y]==0)
           {
               p.ans=t.ans+1;
               q.push(p);
           }
       }
    }
    printf("BOOM\n");
    return ;
}
int main()
{
    int i,j;
    int x,y;
    while(cin>>n>>m>>k)
    {
        memset(flag,0,sizeof(flag));
         for(i=1;i<=n;i++)
         {
             for(j=1;j<=m;j++)
                 cin>>a[i][j];
         }
         cin>>x>>y;
         BFS(x,y);
         memset(a,0,sizeof(a));
    }
    return 0;
}