SPOJ - AMR11J-BFS

原题链接：https://www.spoj.com/problems/AMR11J/en/

暑期训练VJ链接：https://vjudge.net/contest/237052#problem/J

参考博客链接：https://blog.youkuaiyun.com/akahieveman/article/details/52029082

AMR11J - Goblin Wars

The wizards and witches of Hogwarts School of Witchcraft found Prof. Binn's History of Magic lesson to be no less boring than you found your own history classes.  Recently Binns has been droning on about Goblin wars, and which goblin civilization fought which group of centaurs where etc etc.  The students of Hogwarts decided to use the new-fangled computer to figure out the outcome of all these wars instead of memorizing the results for their upcoming exams.  Can you help them?

 

civilization fought which group of centaurs where etc etc.  The students of Hogwarts decided to use the new-fangled computer to figure out the outcome of all these wars instead of memorizing the results for their upcoming exams.  Can you help them?

The magical world looks like a 2-D R*C grid. Initially there are many civilizations, each civilization occupying exactly one cell. A civilization is denoted by a lowercase letter in the grid. There are also certain cells that are uninhabitable (swamps, mountains, sinkholes etc.) - these cells are denoted by a '#' in the grid. All the other cells - to which the civilizations can move  - are represented by a '.' in the grid.

A cell is said to be adjacent to another cell if they share the same edge - in other words, for a cell (x,y), cells (x-1, y), (x, y-1), (x+1, y), (x, y+1) are adjacent, provided they are within the boundaries of the grid.   Every year each civilization will expand to all unoccupied adjacent cells. If it is already inhabited by some other civilization, it just leaves the cell alone. It is possible that two or more civilizations may move into an unoccupied cell at the same time - this will lead to a battle between the civilizations and the cell will be marked with a '*'. Note that the civilizations fighting in a particular cell do not try to expand from that cell, but will continue to expand from other cells, if possible.

Given the initial grid, output the final state of the grid after no further expansion by any civilization is possible.

Input (STDIN):

The first line contains T, the number of cases. This is followed by T test case blocks.

Each test case contains two integers, R, C.

This is followed by R lines containing a string of length C. The j-th letter in the i-th row describes the state of the cell in year 0.

Each cell is either a

1. '.' which represents an unoccupied cell

2. '#' which represents a cell that cannot be occupied

3. A civilization represented by a lowercase letter ('a' - 'z')

Output (STDOUT):

For each test case, print the final grid after no expansion is possible. Apart from the notations used in the input, use '*' to denote that a battle is being waged in that particular cell. 

Print a blank line at the end of each case.

Constraints:

1 <= R, C <= 500

1 <= T <= 5

Time Limit:  3 s

Memory Limit: 64 MB

Sample Input:

5

3 5

#####

a...b

#####

3 4

####

a..b

####

3 3

#c#

a.b

#d#

3 3

#c#

...

a.b

3 5

.....

.#.#.

a...b

Sample Output:

#####

aa*bb

#####

####

aabb

####

#c#

a*b

#d#

#c#

acb

a*b

aa*bb

a#.#

aa*bb

The magical world looks like a 2-D R*C grid. Initially there are many civilizations, each civilization occupying exactly one cell. A civilization is denoted by a lowercase letter in the grid. There are also certain cells that are uninhabitable (swamps, mountains, sinkholes etc.) - these cells are denoted by a '#' in the grid. All the other cells - to which the civilizations can move  - are represented by a '.' in the grid.

 

A cell is said to be adjacent to another cell if they share the same edge - in other words, for a cell (x,y), cells (x-1, y), (x, y-1), (x+1, y), (x, y+1) are adjacent, provided they are within the boundaries of the grid.   Every year each civilization will expand to all unoccupied adjacent cells. If it is already inhabited by some other civilization, it just leaves the cell alone. It is possible that two or more civilizations may move into an unoccupied cell at the same time - this will lead to a battle between the civilizations and the cell will be marked with a '*'. Note that the civilizations fighting in a particular cell do not try to expand from that cell, but will continue to expand from other cells, if possible.

Given the initial grid, output the final state of the grid after no further expansion by any civilization is possible.

 

Input (STDIN):

The first line contains T, the number of cases. This is followed by T test case blocks.

Each test case contains two integers, R, C.

This is followed by R lines containing a string of length C. The j-th letter in the i-th row describes the state of the cell in year 0.

Each cell is either a

1. '.' which represents an unoccupied cell

2. '#' which represents a cell that cannot be occupied

3. A civilization represented by a lowercase letter ('a' - 'z')

 

Output (STDOUT):

For each test case, print the final grid after no expansion is possible. Apart from the notations used in the input, use '*' to denote that a battle is being waged in that particular cell. 

Print a blank line at the end of each case.

 

Constraints:

1 <= R, C <= 500

1 <= T <= 5

 

Sample Input:

5

3 5

#####

a...b

#####

3 4

####

a..b

####

3 3

#c#

a.b

#d#

3 3

#c#

...

a.b

3 5

.....

.#.#.

a...b

 

Sample Output:

#####

aa*bb

#####

 

####

aabb

####

 

#c#

a*b

#d#

 

#c#

acb

a*b

 

aa*bb

a#.#b

aa*bb

题意：就是很多个国家（国家用'a'-'z'表示），向周围（上下左右）扩张土地，而且扩张的速度是一样的，同时开始扩张，如果在同一个时间（两个及两个以上的国家）扩张到同一个地方，那么就要发生战争，标记为 '*'。有'#'标记的地方不能扩张。

思路：因为扩张速度使一样的，是"横向"更新数据，所以可以想到用的方法是BFS，题目的突破口就是在如何判断这个地方是否需要发生战争。

突破口：需要弄一个变量存储某个国家到这个点的时间。如果他要扩张的这个点不是   '.'  而是其他的国家（例如'a'），那么只需要判断它扩张到这点的时间是否和'a'扩张到这点的时间相同，如果相同则要发生战争（map[i][j]='*'），否则则不发生战争。

 1 #include<stdio.h>
 2 #include<string.h>
 3 #include<queue>
 4 using namespace std;
 5 int T;
 6 char map[505][505];//表示[i][j]该点
 7 int flag[505][505];//表示第一个到[i][j]这个位子的时间
 8 int direction[4][2]={0,1,0,-1,1,0,-1,0};//4个方向 
 9 int R,C;
10 struct Node
11 {
12     int x,y,num;//x,y表示坐标，num表示第几个时间点到达。 
13     char s;//s表示字母 
14 };
15 void BFS()
16 {
17     memset(flag,0,sizeof(flag));
18     queue<Node>q;
19     for (int i=0;i<R;i++)
20     for (int j=0;j<C;j++)
21     {
22         if(map[i][j]>='a'&&map[i][j]<='z')//一开始把所有国家存储入队
23         q.push((Node){i,j,0,map[i][j]});//这一步可以看成
　　　　　　　//new了一个新的Node类的结构体Node.x=i；Node.y=j; Node.num=0; Node.s=map[i][j];————————①
24      }
25      while (!q.empty())//最开始是表示每个国家依次出栈，依次更新向四个方向扩张的情况，后面是表示扩张后的土地再向四周扩张的情况
26      {
27          Node t=q.front();//取栈定
28          q.pop();//出栈
29          if(map[t.x][t.y]=='*') continue;//因为可能是在某个（这里假设是'a'国家）国家当时扩张的时候该点没有被占领，但是后面更新的时候又发生了战争，那么该点就不属于'a'国家，而是发生战争，所以这点跳过，不能扩张
30          for(int i=0;i<4;i++)
31          {
32              int xx=t.x+direction[i][0];
33              int yy=t.y+direction[i][1];
34              if(xx<0||xx>=R||yy<0||yy>=C||map[xx][yy]=='*'||map[xx][yy]=='#')//“超出范围”或者“不能走”或者“发生了战争的地方”
35              {
36                  continue;
37              }
38              if(map[xx][yy]=='.')//可以走，则改变那个点 ，入队 
39              {
40                  map[xx][yy]=t.s;
41                  q.push((Node){xx,yy,t.num+1,map[xx][yy]});//Tip：写法和上方①处的解释一样
42                  flag[xx][yy]=t.num+1;//因为是这个国家在上一个位子的扩张点所以是上一个位子的时间t.num+1 ————————————②
43              }
44              if(map[xx][yy]!=t.s&&flag[xx][yy]==t.num+1)//满足突破口，不同的国家在同一个时间段同一个地方相遇，则要发生战争 
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　//Tip：此处的t.num+1的解释和上面②的一样。
45              map[xx][yy]='*';
46          }
47      }
48 }
49 int main()
50 {
51     while (scanf("%d",&T)!=EOF)
52     {
53         while (T--)
54         {
55             scanf("%d%d",&R,&C);
56             for (int i=0;i<R;i++)
57             scanf("%s",map[i]);
58             BFS();
59             for (int i=0;i<R;i++)
60             printf("%s\n",map[i]);
61         }
62     }
63     return 0;
64  } 

 如果有错的地方还请麻烦指出?。谢谢各位了。

转载于:https://www.cnblogs.com/bendandedaima/p/9287441.html