Red and Black

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 11843    Accepted Submission(s): 7380

Problem Description

There is a rectangular room, covered with square tiles. Each tile is colored either red or black. A man is standing on a black tile. From a tile, he can move to one of four adjacent tiles. But he can‘t move on red tiles, he can move only on black tiles.

Write a program to count the number of black tiles which he can reach by repeating the moves described above.

Input

The input consists of multiple data sets. A data set starts with a line containing two positive integers W and H; W and H are the numbers of tiles in the x- and y- directions, respectively. W and H are not more than 20.

There are H more lines in the data set, each of which includes W characters. Each character represents the color of a tile as follows.

‘.‘ - a black tile 
‘#‘ - a red tile 
‘@‘ - a man on a black tile(appears exactly once in a data set)

Output

For each data set, your program should output a line which contains the number of tiles he can reach from the initial tile (including itself).

Sample Input

6 9
....#.
.....#
......
......
......
......
......
#@...#
.#..#.
11 9
.#.........
.#.#######.
.#.#.....#.
.#.#.###.#.
.#.#[email protected]#.#.
.#.#####.#.
.#.......#.
.#########.
...........
11 6
..#..#..#..
..#..#..#..
..#..#..###
..#..#..#@.
..#..#..#..
..#..#..#..
7 7
..#.#..
..#.#..
###.###
[email protected]
###.###
..#.#..
..#.#..
0 0

Sample Output

45
59
6
13

Source

Asia 2004, Ehime (Japan), Japan Domestic

题目大意：

　　给你一个h*w的棋盘。让你在这个棋盘中找出由@点开始走的‘.’ 有多少个，并且每次只能走相邻的四个方向。

解题思路：

　　这题bfs和dfs都能过的，为的就是加强dfs和bfs的思想，最近做的比赛的时候，感觉自己对于基础算法的理解还不是很到位，所以，加强这方面的练习，从最为基础的

题目来加深理解。bfs的时候，我们要把node压入队列，并且在每次can_move判断后就要对其进行新的入队操作。然后，bfs的解题思路就是说从当前的@点开始，一步一步的走完所有@周围的点，每次我们的扩展按照从“从小到大”的原则来进行，也就是说，我们第一次扩展是把距离@为1的点加入队列，把这个状态结束后，我们就把距离@为2的点加入队列，当这个状态结束后，我们再把距离@为3的点加入队列，，，一直到我们扩展完所有的状态最终使得我们的队列为空，这个时候，我们的解就找到了。

　　而用dfs来做的时候，就相当于一条路走到黑的原则，每找到一个‘.‘点后，就用‘#‘来替换他，直到跑完整个地图的所有位置，输出‘#‘的位置就可以了， 实际上就是can_move()函数的编写了.

bfs代码：

 1 # include<cstdio>
 2 # include<iostream>
 3 # include<queue>
 4 # include<cstring>
 5
 6 using namespace std;
 7
 8 # define MAX 23
 9
10 char grid[MAX][MAX];
11 int book[MAX][MAX];
12 int w,h;
13
14 int nxt[4][2] = {{1,0},{0,-1},{-1,0},{0,1}};
15
16 struct node
17 {
18     int x,y;
19     char val;
20 };
21
22 int can_move ( int x,int y )
23 {
24     if ( x>=0&&x<h&&y>=0&&y<w&&book[x][y]==0&&grid[x][y]==‘.‘ )
25         return 1;
26     else
27         return 0;
28 }
29
30 int bfs ( node start )
31 {
32     int cnt = 0;
33     queue<node>Q;
34     Q.push(start);
35     start.val = ‘#‘;
36     while ( !Q.empty() )
37     {
38         node now = Q.front();
39         Q.pop();
40         for ( int i = 0;i < 4;i++ )
41         {
42             int tx = now.x+nxt[i][0], ty = now.y+nxt[i][1];
43             if ( can_move(tx,ty) )
44             {
45                 book[tx][ty] = 1;
46                 node newnode;
47                 newnode.x = tx, newnode.y = ty, newnode.val = ‘#‘;
48                 cnt++;
49                 Q.push(newnode);
50             }
51         }
52     }
53     return cnt;
54 }
55
56
57 int main(void)
58 {
59     while ( scanf("%d%d",&w,&h)!=EOF )
60     {
61         if ( w==0&&h==0 )
62             break;
63         memset(grid,0,sizeof(grid));
64         for ( int i = 0;i < h;i++ )
65         {
66             scanf("%s",grid[i]);
67         }
68         int stx,sty;
69         for ( int i = 0;i < h;i++ )
70         {
71             for ( int j = 0;j < w;j++ )
72             {
73                 if ( grid[i][j]==‘@‘ )
74                 {
75                     stx = i;
76                     sty = j;
77                 }
78             }
79         }
80         book[stx][sty] = 1;
81         node start;
82         start.x = stx, start.y = sty, start.val = ‘@‘;
83         int ans = bfs(start);
84         printf("%d\n",ans+1);
85         memset(book,0,sizeof(book));
86     }
87
88
89     return 0;
90 }

dfs代码:

 1 # include<cstdio>
 2 # include<iostream>
 3 # include<cstring>
 4
 5 using namespace std;
 6
 7 # define MAX 23
 8
 9 char grid[MAX][MAX];
10 int book[MAX][MAX];
11 int nxt[4][2] = {{1,0},{0,-1},{-1,0},{0,1}};
12 int h,w;
13 int cnt;
14
15 int can_move ( int x,int y )
16 {
17     if( x>=0&&x<h&&y>=0&&y<w&&book[x][y]==0&&grid[x][y]==‘.‘ )
18         return 1;
19     else
20         return 0;
21 }
22
23 void dfs ( int x,int y )
24 {
25     book[x][y] = 1;
26     for ( int i = 0;i < 4;i++ )
27     {
28         int tx = x+nxt[i][0], ty = y+nxt[i][1];
29         if ( can_move(tx,ty) )
30         {
31             cnt++;
32             book[tx][ty] = 1;
33             dfs(tx,ty);
34         }
35     }
36     return;
37 }
38
39 int main(void)
40 {
41     while ( scanf("%d%d",&w,&h)!=EOF )
42     {
43         if ( h==0&&w==0 )
44             break;
45         cnt = 0;
46         memset(grid,0,sizeof(grid));
47         for ( int i = 0;i < h;i++ )
48         {
49             scanf("%s",grid[i]);
50         }
51         int stx,sty;
52         for ( int i = 0;i < h;i++ )
53         {
54             for ( int j = 0;j < w;j++ )
55             {
56                 if ( grid[i][j]==‘@‘ )
57                 {
58                     stx = i;
59                     sty = j;
60                 }
61             }
62         }
63         dfs(stx,sty);
64         printf("%d\n",cnt+1);
65         memset(book,0,sizeof(book));
66     }
67
68
69     return 0;
70 }