IOI 2009：Mecho

IOI2009 Mecho

Time Limit: 10000ms

Memory Limit: 262144KB

This problem will be judged on SPOJ. Original ID: CTOI09_1
64-bit integer IO format: %lld      Java class name: Main

Mecho the bear has found a little treasure - the bees' secret honeypot, which is full of honey! He was happily eating his newfound treasure until suddenly one bee saw him and sounded the bee alarm. He knows that at this very moment hordes of bees will emerge from their hives and start spreading around trying to catch him. He knows he has to leave the honeypot and go home quickly, but the honey is so sweet that Mecho doesn't want to leave too soon. Help Mecho determine the latest possible moment when he can leave.

Mecho's forest is represented by a square grid of  by  unit cells, whose sides are parallel to the north-south and east-west directions. Each cell is occupied by a tree, by a patch of grass, by a hive or by Mecho's home. Two cells are considered adjacent if one of them is immediately to the north, south, east or west of the other (but not on a diagonal). Mecho is a clumsy bear, so every time he makes a step, it has to be to an adjacent cell. Mecho can only walk on grass and cannot go through trees or hives, and he can make at most steps per minute. At the moment when the bee alarm is sounded, Mecho is in the grassy cell containing the honeypot, and the bees are in every cell containing a hive (there may be more than one hive in the forest). During each minute from this time onwards, the following events happen in the following order:

• If Mecho is still eating honey, he decides whether to keep eating or to leave. If he continues eating, he does not move for the whole minute. Otherwise, he leaves immediately and takes up to  steps through the forest as described above. Mecho cannot take any of the honey with him, so once he has moved he cannot eat honey again.
• After Mecho is done eating or moving for the whole minute, the bees spread one unit further across the grid, moving only into the grassy cells. Specifically, the swarm of bees spreads into every grassy cell that is adjacent to any cell already containing bees. Furthermore, once a cell contains bees it will always contain bees (that is, the swarm does not move, but it grows).

In other words, the bees spread as follows: When the bee alarm is sounded, the bees only occupy the cells where the hives are located. At the end of the first minute, they occupy all grassy cells adjacent to hives (and still the hives themselves). At the end of the second minute, they additionally occupy all grassy cells adjacent to grassy cells adjacent to hives, and so on. Given enough time, the bees will end up simultaneously occupying all grassy cells in the forest that are within their reach. Neither Mecho nor the bees can go outside the forest. Also, note that according to the rules above, Mecho will always eat honey for an integer number of minutes. The bees catch Mecho if at any point in time Mecho finds himself in a cell occupied by bees.

Task

Write a program that, given a map of the forest, determines the largest number of minutes that Mecho can continue eating honey at his initial location, while still being able to get to his home before any of the bees catch him.

Constraints

 - the size (side length) of the map
 - the maximum number of steps Mecho can take in each minute

Input

The input contains several testcases.

The fist line contains the number of testcase T.

Each testcase has the form as following:

• The first line contains the integers  and , separated by a space.
• The next  lines represent the map of the forest. Each of these lines contains  characters with each character representing one unit cell of the grid. The possible characters and their associated meanings are as follows:

  T denotes a tree G denotes a grassy cell M denotes the initial location of Mecho and the honeypot, which is also a grassy cell D denotes the location of Mecho's home, which Mecho can enter, but the bees cannot. H denotes the location of a hive

Note: It is guaranteed that the map will contain exactly one letter M, exactly one letter D and at least one letter H. It is also guaranteed that there is a sequence of adjacent letters Gthat connects Mecho to his home, as well as a sequence of adjacent letters G that connects at least one hive to the honeypot (i.e., to Mecho's initial location). These sequences might be as short as length zero, in case Mecho's home or a hive is adjacent to Mecho's initial location. Also, note that the bees cannot pass through or fly over Mecho's home. To them, it is just like a tree.

Output

For each test , your program must write to standard output a single line containing a single integer: the maximum possible number of minutes that Mecho can continue eating honey at his initial location, while still being able to get home safely. If Mecho cannot possibly reach his home before the bees catch him, the number your program writes to standard output must be  instead.

Grading

For a number of tests, worth a total of 40 points,  will not exceed 60.

Example

For the input data:

1

7 3
TTTTTTT
TGGGGGT
TGGGGGT
MGGGGGD
TGGGGGT
TGGGGGT
THHHHHT

the correct result is:

1

Explanation of the example: After eating honey for one minute, Mecho can take the shortest path directly to the right and he will be home in another two minutes, safe from the bees.

For the input data:

1

7 3

TTTTTTT

TGGGGGT

TGGGGGT

MGGGGGD

TGGGGGT

TGGGGGT

TGHHGGT

the correct result is:

2

Explanation of the example: After eating honey for two minutes, Mecho can take steps  during the third minute, then steps  during the fourth minute and steps during the fifth minute.

 

Source

IOI 2009

 

　　这题很简单，但容易打错。

　　题解什么的都略过了吧~~~

　　吾不言。

 #include <iostream>
 #include <cstring>
 #include <cstdio>
 #include <queue>
 using namespace std;
 const int INF=;
 char map[][];
 int dis[][];
 int Time[][];
 int n,k;
 struct Data{
     int x,y;
 }S;
 void P()
 {
     queue<Data>q;
     for(int i=;i<=n;i++)
         for(int j=;j<=n;j++)
             if(map[i][j]=='H')
                 q.push((Data){i,j});
             else if(map[i][j]!='T')
                 dis[i][j]=INF;    

     while(!q.empty())
     {
         Data node=q.front();q.pop();
         if((map[node.x+][node.y]=='G'||map[node.x+][node.y]=='M')
                     &&dis[node.x+][node.y]>dis[node.x][node.y]+)
             dis[node.x+][node.y]=dis[node.x][node.y]+,q.push((Data){node.x+,node.y});
         if((map[node.x-][node.y]=='G'||map[node.x-][node.y]=='M')
                     &&dis[node.x-][node.y]>dis[node.x][node.y]+)
             dis[node.x-][node.y]=dis[node.x][node.y]+,q.push((Data){node.x-,node.y});
         if((map[node.x][node.y+]=='G'||map[node.x][node.y+]=='M')
                     &&dis[node.x][node.y+]>dis[node.x][node.y]+)
             dis[node.x][node.y+]=dis[node.x][node.y]+,q.push((Data){node.x,node.y+});
         if((map[node.x][node.y-]=='G'||map[node.x][node.y-]=='M')
                     &&dis[node.x][node.y-]>dis[node.x][node.y]+)
             dis[node.x][node.y-]=dis[node.x][node.y]+,q.push((Data){node.x,node.y-});
     }
     return;
 }

 bool DFS(int t)
 {
     if(t>=dis[S.x][S.y])return false;
     queue<Data>q;
     q.push((Data){S.x,S.y});
     for(int i=;i<=n;i++)
         for(int j=;j<=n;j++)
             Time[i][j]=INF;
     Time[S.x][S.y]=t*k+;

     while(!q.empty())
     {
         Data node=q.front();q.pop();
         int nt=Time[node.x][node.y];
         if(dis[node.x+][node.y]>nt/k&&Time[node.x+][node.y]>nt+){
             Time[node.x+][node.y]=nt+;q.push((Data){node.x+,node.y});
             if(map[node.x+][node.y]=='D')
                 return true;
         }

         if(dis[node.x-][node.y]>(nt)/k&&Time[node.x-][node.y]>nt+){
             Time[node.x-][node.y]=nt+,q.push((Data){node.x-,node.y});
             if(map[node.x-][node.y]=='D')
                 return true;
         }

         if(dis[node.x][node.y+]>(nt)/k&&Time[node.x][node.y+]>nt+){
             Time[node.x][node.y+]=nt+,q.push((Data){node.x,node.y+});
             if(map[node.x][node.y+]=='D')
                 return true;
         }

         if(dis[node.x][node.y-]>(nt)/k&&Time[node.x][node.y-]>nt+){
             Time[node.x][node.y-]=nt+,q.push((Data){node.x,node.y-});
             if(map[node.x][node.y-]=='D')
                 return true;
         }
     }
     return false;
 }
 int main()
 {
     scanf("%d%d",&n,&k);
     for(int i=;i<=n;i++)
         scanf("%s",map[i]+);

     for(int i=;i<=n;i++)
         for(int j=;j<=n;j++)
             if(map[i][j]=='M'){
                 S.x=i;S.y=j;
             }
     P();
     int lo=,hi=;
     while(lo<=hi)
     {
         int mid=(lo+hi)>>;
         if(DFS(mid))lo=mid+;
         else hi=mid-;
     }
     printf("%d\n",hi);
     return ;
 }