八连块

题目：输入一个n*n的黑白图像（1表示黑色，0表示白色），任务是统计其中八连块的个数。如果两个黑格子有公共边或者公共顶点，就说它们属于同一个八连块。如图表示3个八连块

                                                                                                          

[cpp] view plain copy

1. //Depth-First Search  
2. #include <stdio.h>  
3. #include <string.h>  
4. #define MAX 100  
5.   
6. int mat[MAX][MAX], vis[MAX][MAX];  
7.   
8. void dfs(int x, int y)  
9. {//深度优先搜索  
10.     if (!mat[x][y] || vis[x][y])  
11.     {//曾经访问过这个格子，或者当前格子是白色  
12.         return;  
13.     }  
14.     vis[x][y] = 1;  //标记（x, y）已访问过  
15.   
16.     //递归访问周围的八个格子  
17.     dfs(x-1, y-1);  dfs(x-1, y);    dfs(x-1, y+1);  
18.     dfs(x, y-1);                    dfs(x, y+1);  
19.     dfs(x+1, y-1);  dfs(x+1, y);    dfs(x+1, y+1);  
20. }  
21.   
22. int main(void)  
23. {  
24.     int n, i, j;  
25.     int count;  
26.     char s[MAX];  
27.     memset(mat, 0, sizeof(mat));//将所有的格子都初始化为白色，包括周围一圈虚拟格子  
28.     memset(vis, 0, sizeof(vis));//所有的格子都没有访问过  
29.     scanf("%d", &n);  
30.     for (i=0; i< n; i++)  
31.     {  
32.         memset(s, 0, sizeof(s));  
33.         scanf("%s", s);  
34.         for (j=0; j<n; j++)  
35.         {  
36.             mat[i+1][j+1] = s[j] - '0'; //把图像往中间移动一点，空出一圈白格  
37.         }  
38.     }  
39.     count = 0;  
40.     for (i=1; i<=n; i++)  
41.     {  
42.         for (j=1; j<=n; j++)  
43.         {  
44.             if (!vis[i][j] && mat[i][j])  
45.             {//寻找没有访问过的黑格子  
46.                 count++;  
47.                 dfs(i, j);  
48.             }  
49.         }  
50.     }  
51.     printf("%d\n", count);  
52.     return 0;  
53. }  

 

DFS(Depth-First Search) 用到的是栈，递归调用时会把局部变量（当前结点编号）存入栈帧中，如果图像太大，递归方式的DFS有栈溢出的危险。为保险起见，可以用显式栈来代替递归调用。如下

[cpp] view plain copy

1. //Depth-First Search  
2. #include <stdio.h>  
3. #include <string.h>  
4. #define MAX 100  
5.   
6. int mat[MAX][MAX], vis[MAX][MAX];  
7. int s[MAX];//显式栈的栈应为全局变量，因为局部变量定义在栈里面  
8.   
9. int dx[8] = {-1,-1,-1,0,0,1,1,1};//方向定位  
10. int dy[8] = {-1,0,1,-1,1,-1,0,1};  
11.   
12. void dfs(int x, int y)  
13. {//深度优先搜索  
14.     int u = x*8+y;//u代表(x,y)在数组中的编号，即用一个数表示(x,y)的位置  
15.     int top = 0;  
16.     s[top++] = u;//将(x,y)的位置存放在栈中  
17.     vis[x][y] = 1;//访问记录  
18.     while (top)  
19.     {//栈非空时  
20.         u = s[--top];//取出栈顶存储的块的编号  
21.         x = u/8;    y = u%8;//将编号还原为坐标  
22.         for (int d=0; d<8; d++)  
23.         {//i代表要走的8个方向  
24.             int nx = x + dx[d], ny = y + dy[d];//(nx, ny)代表下一个访问位置，即访问一个新块  
25.             if (mat[nx][ny] && !vis[nx][ny])  
26.             {//若(nx, ny)为黑色图且没被访问过  
27.                 int v = nx * 8 + ny;//获取新块的编号  
28.                 vis[nx][ny] = 1;//访问记录  
29.                 s[top++] = v;//将新块放入栈  
30.                 d = -1;//重新遍历新块的四周  
31.                 x = nx; y = ny;//新块编号变成旧块坐标  
32.             }  
33.         }  
34.     }  
35. }  
36.   
37. int main(void)  
38. {  
39.     int n, i, j;  
40.     int count;  
41.     char s[MAX];  
42.     memset(mat, 0, sizeof(mat));//将所有的格子都初始化为白色，包括周围一圈虚拟格子  
43.     memset(vis, 0, sizeof(vis));//所有的格子都没有访问过  
44.     scanf("%d", &n);  
45.     for (i=0; i< n; i++)  
46.     {  
47.         memset(s, 0, sizeof(s));  
48.         scanf("%s", s);  
49.         for (j=0; j<n; j++)  
50.         {  
51.             mat[i+1][j+1] = s[j] - '0'; //把图像往中间移动一点，空出一圈白格  
52.         }  
53.     }  
54.     count = 0;  
55.     for (i=1; i<=n; i++)  
56.     {  
57.         for (j=1; j<=n; j++)  
58.         {  
59.             if (!vis[i][j] && mat[i][j])  
60.             {//寻找没有访问过的黑格子  
61.                 count++;  
62.                 dfs(i, j);  
63.             }  
64.         }  
65.     }  
66.     printf("%d\n", count);  
67.     return 0;  
68. }