UESTC_Infected Land 2015 UESTC Training for Search Algorithm & String<Problem G>

G - Infected Land

Time Limit: 6000/3000MS (Java/Others)     Memory Limit: 65535/65535KB (Java/Others)

Submit Status

The earth is under an attack of a deadly virus. Luckily, prompt actions of the Ministry of Health against this emergency successfully confined the spread of the infection within a square grid of areas. Recently, public health specialists found an interesting pattern with regard to the transition of infected areas. At each step in time, every area in the grid changes its infection state according to infection states of its directly (horizontally, vertically, and diagonally) adjacent areas.

• An infected area continues to be infected if it has two or three adjacent infected areas.
• An uninfected area becomes infected if it has exactly three adjacent infected areas.
• An area becomes free of the virus, otherwise.

Your mission is to fight against the virus and disinfect all the areas. The Ministry of Health lets an anti-virus vehicle prototype under your command. The functionality of the vehicle is summarized as follows.

At the beginning of each time step, you move the vehicle to one of the eight adjacent areas. The vehicle is not allowed to move to an infected area (to protect its operators from the virus). It is not allowed to stay in the same area.

Following vehicle motion, all the areas, except for the area where the vehicle is in, change their infection states according to the transition rules described above.

Special functionality of the vehicle protects its area from virus infection even if the area is adjacent to exactly three infected areas. Unfortunately, this virus-protection capability of the vehicle does not last. Once the vehicle leaves the area, depending on the infection states of the adjacent areas, the area can be infected.

The area where the vehicle is in, which is uninfected, has the same effect to its adjacent areas as an infected area as far as the transition rules are concerned. The following series of figures illustrate a sample scenario that successfully achieves the goal.

Initially, your vehicle denoted by @ is found at (1,5) in a 5×5-grid of areas, and you see some infected areas which are denoted by #'s.

Firstly, at the beginning of time step 1, you move your vehicle diagonally to the southwest, that is, to the area (2,4). Note that this vehicle motion was possible because this area was not infected at the start of time step 1.

Following this vehicle motion, infection state of each area changes according to the transition rules. The column "1-end" of the figure illustrates the result of such changes at the end of time step 1. Note that the area (3,3) becomes infected because there were two adjacent infected areas and the vehicle was also in an adjacent area, three areas in total.

In time step 2, you move your vehicle to the west and position it at (2,3).

Then infection states of other areas change. Note that even if your vehicle had exactly three infected adjacent areas (west, southwest, and south), the area that is being visited by the vehicle is not infected. The result of such changes at the end of time step 2 is as depicted in "2-end".

Finally, in time step 3, you move your vehicle to the east. After the change of the infection states, you see that all the areas have become virus free! This completely disinfected situation is the goal. In the scenario we have seen, you have successfully disinfected all the areas in three time steps by commanding the vehicle to move (1) southwest, (2) west, and (3) east.

Your mission is to find the length of the shortest sequence(s) of vehicle motion commands that can successfully disinfect all the areas.

Input

The input is a sequence of datasets. The end of the input is indicated by a line containing a single zero. Each dataset is formatted as sample input.

Here, n is the size of the grid. That means that the grid is comprised of n×n areas. You may assume 1≤n≤5. The rest of the dataset consists of n lines of n letters. Each letter aij specifies the state of the area at the beginning: # for infection, . for free of virus, and @ for the initial location of the vehicle. The only character that can appear in a line is #, ., or @. Among n × n areas, there exists exactly

Output

For each dataset, output the minimum number of time steps that is required to disinfect all the areas. If there exists no motion command sequence that leads to complete disinfection, output−1. The output should not contain any other extra character.

Sample input and output

Sample Input	Sample Output
3 ... .@. ... 3 .## .#. @## 3 ##. #.. @.. 5 ....@ ##... #.... ...#. ##.## 5 #...# ...#. #.... ...## ..@.. 5 #.... ..... ..... ..... ..@.. 5 #..#. #.#.# .#.#. ....# .#@## 5 ..##. ..#.. #.... #.... .#@.. 0	0 10 -1 3 2 1 6 4

解题报告

这是一道二进制状态压缩搜索题目，地图大小最大是 5*5 ，每个点只有感染和不感染两种状态，用一个int即可存下.

之后考虑判重，因为int太大，其实我们用到的状态并没有那么多，故我们采用哈希表来判重.

唯一需要注意的是医疗车本身也看成感染的点....

#include <iostream>
#include <cstring>
#include <cstdio>

using namespace std;
const int MaxHashSize = ;
const int MaxStatusSize = ;
typedef struct status
{
  int x,y,val,step;
};

status str;
int n;
int head[MaxHashSize];
int new_next[MaxStatusSize];
status st[MaxStatusSize];
status q[MaxStatusSize];
int dir[][] = {-,,,,,-,,,-,-,,-,-,,,};

int getval(const status &x,bool flag[][] )
{
   for(int i =  ; i < n ; ++ i)
    for(int j =  ; j < n ; ++ j)
     if ((x.val>> (i*n+j)) & )
      flag[i][j] = true;
}

int gethashval(int x)
{
   return x % MaxHashSize;
}

inline bool inmap(int x,int y)
{
   if (x >= n || x <  || y >= n || y < )
    return false;
   return true;
}

void init_hash()
{
   memset(head,-,sizeof(head));
}

bool insert(int id)
{
   int val = gethashval(st[id].val);
   int u = head[val];
   while(u != -)
    {
       if (st[id].val == st[u].val && st[id].x == st[u].x && st[id].y == st[u].y)
        return false;
       u = new_next[u];
    }
   new_next[id] = head[val];
   head[val] = id;
   return true;
}

void dump(bool flag[][])
{
   for(int i =  ; i < n ; ++ i)
    {
        for(int j =  ; j < n ; ++ j)
         printf("%d",flag[i][j]);
        printf("\n");
    }
}

int bfs()
{
  int front =  , rear = ;
  st[rear] = str;
  insert(rear++);
  while(front < rear)
   {
          status &ns = st[front++];
          int x = ns.x , y = ns.y , val = ns.val , step = ns.step;
          if ( !(val ^ ( << (x*n+y))))
           return step;
          bool g[][];
          memset(g,false,sizeof(g));
          getval(ns,g);
          for(int i =  ; i <  ; ++ i)
           {
              int newx = x + dir[i][];
              int newy = y + dir[i][];
              if (!inmap(newx,newy) || g[newx][newy])
               continue;
              int newval = val;
              newval ^= ( << (x*n+y));
              newval ^= ( << (newx*n+newy));
              st[rear].step = step+;
              st[rear].x = newx , st[rear].y = newy;
              g[newx][newy] = true;
              g[x][y] = false;
              for(int j =  ; j < n ; ++ j)
               for(int k =  ; k < n ; ++ k)
                {
                    if (j == newx && k == newy)
                     continue;
                    int cot = ;
                    for(int z =  ; z <  ; ++ z)
                     {
                         int newr = j + dir[z][];
                     int newt = k + dir[z][];
                     if (!inmap(newr,newt))
                      continue;
                     if (g[newr][newt])
                      cot++;
                 }
                if (g[j][k])
                 {
                     if (cot !=  && cot != )
                      newval &= ~(<<(j*n+k));
                 }
                else
                 {
                     if (cot == )
                      newval |= (<<(j*n+k));
                 }
             }
           g[x][y] = true;
           g[newx][newy] = false;
           st[rear].val = newval;
           if (insert(rear))
            {
                rear++;
            }

        }
   }
  return -;
}

char buffer[][];

int main(int argc,char *argv[])
{
  while(scanf("%d",&n) && n)
   {
          for(int i =  ; i < n ; ++ i)
           scanf("%s",buffer[i]);
          init_hash();
          str.val = ;
          for(int i = ; i < n ; ++ i)
           for(int j =  ; j < n ; ++ j)
            {
                if (buffer[i][j] == '@')
                 str.x = i ,str.y = j,str.val |= (<<(i*n+j));
                else if(buffer[i][j] == '#')
                 str.val |= (<<(i*n+j));
         }
       str.step = ;
       printf("%d\n",bfs());
   }
  return ;
}