小白书上经典DFS题目。

1. 递归实现

  1. // from: https://www.cnblogs.com/huaszjh/p/4686092.html
  3. #include <stdio.h>
  4. #include <string.h>
  5. #define maxn 105
  6. unsigned char data[maxn][maxn];
  7. int m, n, vis[maxn][maxn];
  9. void dfs(int x, int y, int ans) {
  10. 	if (x < 0 || x >= m || y < 0 || y >= n) return; //出界
  11. 	if (vis[x][y] > 0 || data[x][y] == '*') return; //非'@'或已经访问
  12. 	vis[x][y] = ans; //连通分量编号
  13. 	for (int k = -1; k <= 1; k++) {
  14. 		for (int t = -1; t <= 1; t++) {
  15. 			if (k != 0 || t != 0) { //自身格子不需要重复判断
  16. 				dfs(x + k, y + t, ans);
  17. 			}
  18. 		}
  19. 	}
  20. }
  22. #define DEBUG
  23. int main() {
  24. #ifdef DEBUG
  25. 	const char* input_txt_pth = "F:/zhangzhuo/debug/OJ/UVA-572.txt";
  26. 	freopen(input_txt_pth, "r", stdin);
  27. #endif
  29. 	int i, j;
  30. 	while (scanf("%d %d", &m, &n) && m &&n) {
  31. 		int count = 0; //连通块
  32. 		memset(vis, 0, sizeof(vis));
  33. 		for (i = 0; i < m; i++) {
  34. 			scanf("%s", data[i]);
  35. 		}
  36. 		for (i = 0; i < m; i++) {
  37. 			for (j = 0; j < n; j++) {
  38. 				//对未访问且为`@`的格子进行访问
  39. 				if (vis[i][j] == 0 && data[i][j] == '@') {
  40. 					dfs(i, j, ++count);
  41. 				}
  42. 			}
  43. 		}
  44. 		printf("%d\n", count);
  45. #ifdef DEBUG
  46. 		for (i = 0; i < m; i++) {
  47. 			for (j = 0; j < n; j++) {
  48. 				printf("%3d", vis[i][j]);
  49. 			}
  50. 			printf("\n");
  51. 		}
  52. 		printf("\n");
  53. #endif
  54. 	}
  55. 	return 0;
  56. }

2. 递归dfs函数用迭代实现

每个节点的dfs递归调用，改成用stack容器就地计算，是个while循环，本质上还是栈，但是避免了递归时嵌套产生的开销造成的潜在风险。

C++的stack、vector容器用起来比较顺手。另外就是把坐标简单封装为一个结构体。

  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <iostream>
  4. #include <stack>
  5. #include <vector>
  7. typedef struct Coord {
  8. 	char x, y;
  9. } Coord;
  11. #define DEBUG
  12. int main() {
  13. #ifdef DEBUG
  14. 	const char* input_txt_pth = "F:/zhangzhuo/debug/OJ/UVA-572.txt";
  15. 	freopen(input_txt_pth, "r", stdin);
  16. #endif
  18. 	int m, n, i, j;
  20. 	#define maxn 105
  21. 	unsigned char data[maxn][maxn];
  22. 	int vis[maxn][maxn];
  24. 	while (scanf("%d %d", &m, &n) && m &&n) {
  25. 		int count = 0; //连通块
  26. 		memset(vis, 0, sizeof(vis));
  27. 		for (i = 0; i < m; i++) {
  28. 			scanf("%s", data[i]);
  29. 		}
  31. 		std::stack<Coord> stk;
  32. 		Coord cd;
  33. 		std::vector<Coord>offset;
  34. 		cd.x = -1; cd.y = -1; offset.push_back(cd);
  35. 		cd.x = -1; cd.y = 0; offset.push_back(cd);
  36. 		cd.x = -1; cd.y = 1; offset.push_back(cd);
  37. 		cd.x = 0; cd.y = -1; offset.push_back(cd);
  38. 		cd.x = 0; cd.y = 1; offset.push_back(cd);
  39. 		cd.x = 1; cd.y = -1; offset.push_back(cd);
  40. 		cd.x = 1; cd.y = 0; offset.push_back(cd);
  41. 		cd.x = 1; cd.y = 1; offset.push_back(cd);
  43. 		for (i = 0; i < m; i++) {
  44. 			for (j = 0; j < n; j++) {
  45. 				cd.x = i; cd.y = j;
  46. 				if (vis[cd.x][cd.y] > 0 || data[cd.x][cd.y] != '@') continue;
  47. 				count++;
  49. 				stk.push(cd);
  50. 				while (!stk.empty()) {
  51. 					cd = stk.top();
  52. 					stk.pop();
  53. 					vis[cd.x][cd.y] = count;
  55. 					Coord tmp;
  56. 					for (size_t k = 0; k < offset.size(); k++) {
  57. 						tmp.x = cd.x + offset[k].x;
  58. 						tmp.y = cd.y + offset[k].y;
  59. 						if (tmp.x < 0 || tmp.x >= m || tmp.y < 0 || tmp.y >= n) continue;
  60. 						if (vis[tmp.x][tmp.y] > 0 || data[tmp.x][tmp.y] != '@') continue;
  61. 						stk.push(tmp);
  62. 					}
  63. 				}
  64. 			}
  65. 		}
  67. 		printf("%d\n", count);
  69. #ifdef DEBUG
  70. 		for (i = 0; i < m; i++) {
  71. 			for (j = 0; j < n; j++) {
  72. 				printf("%3d", vis[i][j]);
  73. 			}
  74. 			printf("\n");
  75. 		}
  76. 		printf("\n");
  77. #endif
  78. 	}
  79. 	return 0;
  80. }

3.纯C，DFS非递归，自定义栈ADT，函数指针

  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  6. typedef struct Coord Coord;
  7. struct Coord {
  8. 	char x, y;
  9. };
  11. typedef struct CoordOffset CoordOffset;
  12. struct CoordOffset {
  13. 	size_t num;
  14. 	int* x;
  15. 	int* y;
  16. };
  18. typedef struct ListNode ListNode;
  19. struct ListNode
  20. {
  21. 	ListNode* next;
  22. 	void* data;
  23. };
  25. typedef struct Stack Stack;
  27. struct Stack {
  28. 	ListNode* head;
  29. 	size_t len;
  30. 	void(*push_coord)(Stack* stk, Coord* coord);
  31. 	void (*pop_coord)(Stack* stk);
  32. 	void (*top_coord)(Stack* stk, Coord* coord);
  33. };
  35. void stack_push_coord(Stack* stk, Coord* coord) {
  36. 	ListNode* new_head = (ListNode*)malloc(sizeof(ListNode));
  37. 	/* new_head->data = coord; */
  38. 	new_head->data = (Coord*)malloc(sizeof(ListNode));
  39. 	memcpy(new_head->data, coord, sizeof(Coord));
  41. 	new_head->next = stk->head;
  42. 	stk->head = new_head;
  43. 	stk->len++;
  44. }
  46. void stack_pop_coord(Stack* stk) {
  47. 	if (stk->head != NULL) {
  48. 		ListNode* new_head = stk->head->next;
  49. 		free(stk->head->data);
  50. 		free(stk->head);
  51. 		stk->head = new_head;
  52. 		stk->len--;
  53. 	}
  54. }
  56. void stack_top_coord(Stack* stk, Coord* coord) {
  57. 	if (stk->head != NULL) {
  58. 		Coord* t_coord = (Coord*)(stk->head->data);
  59. 		coord->x = t_coord->x;
  60. 		coord->y = t_coord->y;
  61. 	}
  62. }
  64. void make_stack(Stack** _stk) {
  65. 	Stack* stk = (Stack*)malloc(sizeof(Stack));
  66. 	stk->head = NULL;
  67. 	stk->len = 0;
  68. 	stk->push_coord = stack_push_coord;
  69. 	stk->pop_coord = stack_pop_coord;
  70. 	stk->top_coord = stack_top_coord;
  72. 	/* write back */
  73. 	*_stk = stk;
  74. }
  76. void free_stack(Stack* stk) {
  77. 	ListNode* cur = stk->head;
  78. 	ListNode* temp;
  79. 	size_t i;
  80. 	for (i = 0; i < stk->len; i++) {
  81. 		temp = cur->next;
  82. 		free(cur->data);
  83. 		free(cur);
  84. 		cur = temp;
  85. 	}
  86. 	free(stk);
  87. 	stk = NULL;
  88. }
  90. void make_8coord_offset(CoordOffset** _offset) {
  91. 	CoordOffset* offset = (CoordOffset*)malloc(sizeof(CoordOffset));
  92. 	offset->num = 8;
  93. 	offset->x = (int*)malloc(sizeof(int)*offset->num);
  94. 	offset->y = (int*)malloc(sizeof(int)*offset->num);
  96. 	offset->x[0] = -1; offset->y[0] = -1;
  97. 	offset->x[1] = -1; offset->y[1] =  0;
  98. 	offset->x[2] = -1; offset->y[2] =  1;
  99. 	offset->x[3] =  0; offset->y[3] = -1;
  100. 	offset->x[4] =  0; offset->y[4] =  1;
  101. 	offset->x[5] =  1; offset->y[5] = -1;
  102. 	offset->x[6] =  1; offset->y[6] =  0;
  103. 	offset->x[7] =  1; offset->y[7] =  1;
  105. 	/* write back */
  106. 	*_offset = offset;
  107. }
  109. void free_coord_offset(CoordOffset* offset) {
  110. 	if (offset) {
  111. 		if (offset->x) {
  112. 			free(offset->x);
  113. 			offset->x = NULL;
  114. 		}
  115. 		if (offset->y) {
  116. 			free(offset->y);
  117. 			offset->y = NULL;
  118. 		}
  119. 		free(offset);
  120. 		offset = NULL;
  121. 	}
  122. }
  124. /* #define DEBUG */
  125. int main() {
  126. #ifdef DEBUG
  127. 	const char* input_txt_pth = "F:/zhangzhuo/debug/OJ/UVA-572.txt";
  128. 	freopen(input_txt_pth, "r", stdin);
  129. #endif
  131. 	int m, n, i, j;
  132. 	size_t k;
  134. 	#define maxn 105
  135. 	unsigned char data[maxn][maxn];
  136. 	int vis[maxn][maxn];
  138. 	/* here we use 8 neighbours */
  139. 	CoordOffset* offset = NULL;
  140. 	make_8coord_offset(&offset);
  142. 	while (scanf("%d %d", &m, &n) && m &&n) {
  143. 		int count = 0; /* 连通块 */
  144. 		memset(vis, 0, sizeof(vis));
  145. 		for (i = 0; i < m; i++) {
  146. 			scanf("%s", data[i]);
  147. 		}
  149. 		/* std::stack<Coord> stk; */
  150. 		Stack* stk;
  151. 		make_stack(&stk);
  153. 		Coord cd;
  155. 		for (i = 0; i < m; i++) {
  156. 			for (j = 0; j < n; j++) {
  157. 				cd.x = i; cd.y = j;
  158. 				if (vis[cd.x][cd.y] > 0 || data[cd.x][cd.y] != '@') continue;
  159. 				count++;
  161. 				/* stk.push(cd); */
  162. 				stack_push_coord(stk, &cd);
  163. 				/* while (!stk.empty()) { */
  164. 				while(stk->len!=0) {
  165. 					/* cd = stk.top(); */
  166. 					/* stack_top_coord(stk, &cd); */
  167. 					stk->top_coord(stk, &cd);
  168. 					/* stk.pop(); */
  169. 					/* stack_pop_coord(stk); */
  170. 					stk->pop_coord(stk);
  172. 					vis[cd.x][cd.y] = count;
  174. 					Coord tmp;
  175. 					for (k = 0; k < offset->num; k++) {
  176. 						tmp.x = cd.x + offset->x[k];
  177. 						tmp.y = cd.y + offset->y[k];
  178. 						if (tmp.x < 0 || tmp.x >= m || tmp.y < 0 || tmp.y >= n) continue;
  179. 						if (vis[tmp.x][tmp.y] > 0 || data[tmp.x][tmp.y] != '@') continue;
  180. 						/* stk.push(tmp); */
  181. 						/* stack_push_coord(stk, &tmp); */
  182. 						stk->push_coord(stk, &tmp);
  183. 					}
  184. 				}
  185. 			}
  186. 		}
  187. 		free_stack(stk);
  189. 		printf("%d\n", count);
  191. #ifdef DEBUG
  192. 		for (i = 0; i < m; i++) {
  193. 			for (j = 0; j < n; j++) {
  194. 				printf("%3d", vis[i][j]);
  195. 			}
  196. 			printf("\n");
  197. 		}
  198. 		printf("\n");
  199. #endif
  200. 	}
  202. 	free_coord_offset(offset);
  203. 	return 0;
  204. }

4.DFS+并查集实现

  1. #include <stdio.h>
  2. #include <stdio.h>
  3. #include <string.h>
  4. #include <stdlib.h>
  6. int fa[10500];
  7. int m, n, cnt, vis[105][105];
  8. char mp[105][105];
  9. int find(int x) {
  10. 	if (fa[x] == x) return x;
  11. 	fa[x] = find(fa[x]);
  12. 	return fa[x];
  13. }
  15. void merge(int x, int y) {
  16. 	int fx = find(x);
  17. 	int fy = find(y);
  18. 	if (fx == fy) return;
  19. 	fa[fx] = fy;
  20. }
  22. void dfs(int x, int y, int fx, int fy) {
  23. 	if (x < 0 || x >= m || y < 0 || y >= n) return;
  24. 	if (vis[x][y] || mp[x][y] == '*') return;
  25. 	vis[x][y] = 1;
  26. 	/* cout<<"x || y || fx || fy : "<<x<<" || "<<y<<" || "<<fx<<" || "<<fy<<endl; */
  27. 	if (fx != -1) {
  28. 		merge(x*m + y, fx*m + fy);
  29. 	}
  30. 	int i, j;
  31. 	for (i = -1; i < 2; i++) {
  32. 		for (j = -1; j < 2; j++) {
  33. 			if (!i && !j) continue;
  34. 			dfs(x + i, y + j, x, y);
  35. 		}
  36. 	}
  37. }
  39. /* #define LOCAL */
  40. int main() {
  41. #ifdef LOCAL
  42. 	const char* input_txt = "F:/zhangzhuo/debug/OJ/UVA-572.txt";
  43. 	freopen(input_txt, "r", stdin);
  44. #endif
  45. 	int i, j;
  46. 	while (scanf("%d%d", &m, &n) == 2 && m && n) {
  47. 		cnt = 0;
  48. 		memset(vis, 0, sizeof(vis));
  49. 		for (i = 0; i < m; i++) {
  50. 			scanf("%s", mp[i]);
  51. 		}
  52. 		for (i = 0; i < 10500; i++) {
  53. 			fa[i] = i;
  54. 		}
  55. 		for (i = 0; i < m; i++) {
  56. 			for (j = 0; j < n; j++) {
  57. 				if (!vis[i][j] && mp[i][j] == '@') {
  58. 					dfs(i, j, -1, -1);
  59. 					cnt++;
  60. 				}
  61. 			}
  62. 		}
  63. 		printf("%d\n", cnt);
  65. #ifdef LOCAL
  66. 		for (i = 0; i < m; i++) {
  67. 			for (j = 0; j < n; j++) {
  68. 				printf("%3d", vis[i][j]);
  69. 			}
  70. 			printf("\n");
  71. 		}
  72. 		printf("\n");
  73. #endif
  75. 	}
  76. 	return 0;
  77. }

5.DFS+并查集+不使用全局变量+简单封装为结构体

修改自 UVA572 (并查集解法) 。这种写法有点问题：已经用了dfs，dfs里用并查集多此一举，如果用并查集就不应该递归调用dfs。

  1. #include <stdio.h>
  2. #include <stdio.h>
  3. #include <string.h>
  4. #include <stdlib.h>
  6. typedef struct FSU_Node {
  7. 	int p;    /* parent id */
  8. 	int rank;
  9. 	int vis; /* group(connected component) id */
  10. } FSU_Node;
  12. /*
  13. get node's root id
  14. @param x: node id
  15. @param nodes: all nodes in map
  16. */
  17. int fus_find(int x, FSU_Node* nodes) {
  18. 	if (nodes[x].p == x) return x;
  20. 	nodes[x].p = fus_find(nodes[x].p, nodes);
  21. 	return nodes[x].p;
  22. }
  24. /*
  25. merge two node groups
  26. @param a: a node from one node group
  27. @param b: a node from another node group
  28. */
  29. void fus_union(int a, int b, FSU_Node* nodes)
  30. {
  31. 	int ra = fus_find(a, nodes); /* ra: root id of a */
  32. 	int rb = fus_find(b, nodes); /* rb: root id of b */
  33. 	if (ra == rb) {
  34. 		return;
  35. 	}
  37. 	if (nodes[ra].rank > nodes[rb].rank)
  38. 	{
  39. 		nodes[rb].p = ra;
  40. 	}
  41. 	else {
  42. 		if (nodes[ra].rank == nodes[rb].rank)
  43. 		{
  44. 			nodes[rb].rank++;
  45. 		}
  46. 		nodes[ra].p = rb;
  47. 	}
  48. }
  50. typedef struct ImageSize {
  51. 	int w, h;
  52. } ImageSize;
  54. typedef struct Coord {
  55. 	int row, col;
  56. } Coord;
  58. void fus_dfs(const Coord* pt, const Coord* f_pt, FSU_Node* nodes, ImageSize* sz, unsigned char* mp) {
  59. 	int row = pt->row;
  60. 	int col = pt->col;
  62. 	int f_row = f_pt->row;
  63. 	int f_col = f_pt->col;
  65. 	if (row < 0 || row >= sz->h || col < 0 || col >= sz->w) return;
  67. 	int id = row * sz->w + col;
  68. 	int fid = f_row * sz->w + f_col;
  70. 	/* if (vis[id] || mp[id] == '*') return; */
  71. 	if (nodes[id].vis || mp[id] == '*') return;
  72. 	/* vis[id] = 1; */
  73. 	nodes[id].vis = 1;
  75. 	if (f_row != -1) {
  76. 		fus_union(id, fid, nodes);
  77. 	}
  79. 	int i, j;
  80. 	Coord neighbor;
  81. 	for (i = -1; i < 2; i++) {
  82. 		for (j = -1; j < 2; j++) {
  83. 			if (!i && !j) continue;
  84. 			neighbor.row = row + i;
  85. 			neighbor.col = col + j;
  86. 			fus_dfs(&neighbor, pt, nodes, sz, mp);
  87. 		}
  88. 	}
  89. }
  91. /*#define LOCAL*/
  92. int main() {
  93. #ifdef LOCAL
  94. 	const char* input_txt = "F:/zhangzhuo/debug/OJ/UVA-572.txt";
  95. 	freopen(input_txt, "r", stdin);
  96. #endif
  98. #define MAXN 105
  99. 	int m, n, cnt, i, j;
  101. 	/* int vis[MAXN*MAXN]; */
  102. 	unsigned char mp[MAXN*MAXN];
  103. 	FSU_Node nodes[MAXN*MAXN];
  105. 	int idx;
  107. 	while (scanf("%d%d", &m, &n) == 2 && m && n) {
  108. 		cnt = 0;
  109. 		/* memset(vis, 0, sizeof(int)*MAXN*MAXN); */
  110. 		for (i = 0; i < m; i++) {
  111. 			for (j = 0; j < n; j++) {
  112. 				idx = i * n + j;
  113. 				scanf(" %c", &mp[idx]);
  114. 				/* printf("! %c !", mp[idx]); */
  115. 			}
  116. 		}
  117. 		for (i = 0; i < m*n; i++) {
  118. 			nodes[i].p = idx;
  119. 			nodes[i].rank = 1;
  120. 			nodes[i].vis = 0;
  121. 		}
  123. 		ImageSize im_sz;
  124. 		im_sz.h = m;
  125. 		im_sz.w = n;
  126. 		Coord pt;
  127. 		Coord f_pt;
  128. 		f_pt.row = -1;
  129. 		f_pt.col = -1;
  131. 		for (i = 0; i < m; i++) {
  132. 			for (j = 0; j < n; j++) {
  133. 				idx = i * n + j;
  134. 				/* if (!vis[idx] && mp[idx] == '@') { */
  135. 				if (!nodes[idx].vis && mp[idx] == '@') {
  136. 					/* dfs(i, j, -1, -1); */
  137. 					pt.row = i;
  138. 					pt.col = j;
  139. 					/* fus_dfs(&pt, &f_pt, nodes, &im_sz, vis, mp); */
  140. 					fus_dfs(&pt, &f_pt, nodes, &im_sz, mp);
  141. 					cnt++;
  142. 				}
  143. 			}
  144. 		}
  145. 		printf("%d\n", cnt);
  147. #ifdef LOCAL
  148. 		for (i = 0; i < m; i++) {
  149. 			for (j = 0; j < n; j++) {
  150. 				idx = i * m + j;
  151. 				/* printf("%3d", vis[idx]); */
  152. 				printf("%c", mp[idx]);
  153. 			}
  154. 			printf("\n");
  155. 		}
  156. 		printf("\n");
  157. #endif
  158. 	}
  160. 	return 0;
  161. }

这里的教训是，如果在双重for循环中使用变量x、y来表示坐标，容易把2维度坐标->1维坐标的计算算错。使用row,col能减少犯错可能；

另外就是数据读取，这里改成%c，则需要过滤掉换行符\n，方法是scanf时的格式串首部添加空格：scanf(" %c", &xx)

6. 并查集，去掉了DFS

思路：遍历每个像素点，每个像素点用并查集算法合并周边8邻域中为'@'的像素点。再次遍历，统计每个'@'像素对应的等价类（root节点）的值。第三次遍历，把第二次统计的值当中cnt数大于0的累计，就是区域个数。在统计连通域个数的时候顺带把每个连通域id（像素的parent值）修改为从1开始严格单调增的序列，开启LOCAL和LOCAL_DEBUG宏可以看到。

和通常用的模板写法略有差别，比如返回root的递归终止条件，比如root初值。

不得不说，uDebug是个好东西。

  1. #include <stdio.h>
  2. #include <stdio.h>
  3. #include <string.h>
  4. #include <stdlib.h>
  6. typedef struct FSU_Node {
  7. 	int p;    /* parent id */
  8. 	int rank;
  9. } FSU_Node;
  11. /*
  12. get node's root id
  13. @param x: node id
  14. @param nodes: all nodes in map
  15. */
  17. int fus_find(int x, FSU_Node* nodes) {
  18. 	if (nodes[x].p == x) {
  19. 		return x;
  20. 	}
  22. 	nodes[x].p = fus_find(nodes[x].p, nodes);
  23. 	return nodes[x].p;
  24. }
  26. /*
  27. merge two node groups
  28. @param a: a node from one node group
  29. @param b: a node from another node group
  30. */
  31. void fus_union(int a, int b, FSU_Node* nodes)
  32. {
  33. 	int ra = fus_find(a, nodes); /* ra: root id of a */
  34. 	int rb = fus_find(b, nodes); /* rb: root id of b */
  35. 	if (ra == rb) {
  36. 		return;
  37. 	}
  39. 	if (nodes[ra].rank > nodes[rb].rank) {
  40. 		nodes[rb].p = ra;
  41. 	}
  42. 	else {
  43. 		if (nodes[ra].rank == nodes[rb].rank) {
  44. 			nodes[rb].rank++;
  45. 		}
  46. 		nodes[ra].p = rb;
  47. 	}
  48. }
  50. /* #define LOCAL */
  51. /* #define LOCAL_DEBUG */
  52. int main() {
  53. #ifdef LOCAL
  54. 	const char* input_txt = "F:/zhangzhuo/debug/OJ/UVA-572.txt";
  55. 	freopen(input_txt, "r", stdin);
  56. #endif
  58. #define MAXN 105
  59. 	int m, n, cnt, i, j, k;
  61. 	int shift_x[8] = { -1, -1, -1,  0, 0,  1, 1, 1 };
  62. 	int shift_y[8] = { -1,  0,  1, -1, 1, -1, 0, 1 };
  64. 	unsigned char mp[MAXN*MAXN];
  65. 	FSU_Node nodes[MAXN*MAXN];
  67. 	int idx;
  69. 	while (scanf("%d%d", &m, &n) == 2 && m && n) {
  70. 		cnt = 0;
  71. 		for (i = 0; i < m; i++) {
  72. 			for (j = 0; j < n; j++) {
  73. 				idx = i * n + j;
  74. 				scanf(" %c", &mp[idx]);
  75. 			}
  76. 		}
  77. 		for (i = 0; i < m; i++) {
  78. 			for (j = 0; j < n; j++) {
  79. 				idx = i * n + j;
  80. 				nodes[idx].p = idx;
  81. 				nodes[idx].rank = 1;
  82. 			}
  83. 		}
  85. 		for (i = 0; i < m; i++) {
  86. 			for (j = 0; j < n; j++) {
  87. 				idx = i * n + j;
  88. 				if (mp[idx] != '@') continue;
  89. 				for (k = 0; k < 8; k++) {
  90. 					int row = i + shift_x[k];
  91. 					int col = j + shift_y[k];
  92. 					int neighbor_idx = row * n + col;
  93. 					if (row < 0 || row >= m || col < 0 || col >= n || mp[neighbor_idx] != '@') continue;
  94. 					fus_union(idx, neighbor_idx, nodes);
  95. 				}
  96. 			}
  97. 		}
  99. 		int bowl[MAXN*MAXN] = { 0 };
  100. 		int label_cnt = 0;
  101. 		for (i = 0; i < m*n; i++) {
  102. 			if (mp[i] != '@') continue;
  103. 			int t = fus_find(i, nodes);
  104. 			nodes[i].p = t;
  105. 			if (bowl[t] == 0) {
  106. 				label_cnt++;
  107. 				bowl[t] = label_cnt;
  108. 			}
  109. 		}
  110. 		printf("%d\n", label_cnt);
  112. #ifdef LOCAL_DEBUG
  113. 		/* print out debug info */
  114. 		for (i = 0; i < m; i++) {
  115. 			for (j = 0; j < n; j++) {
  116. 				idx = i * n + j ;
  117. 				if (mp[idx] == '@') {
  118. 					/* printf("%3d", fus_find(idx, nodes)); */
  119. 					/* printf("%3d", nodes[idx].p); */
  120. 					printf("%3d", bowl[nodes[idx].p]);
  121. 				}
  122. 				else {
  123. 					printf("%3c", '*');
  124. 				}
  125. 			}
  126. 			printf("\n");
  127. 		}
  128. 		printf("\n");
  129. #endif
  131. 	}
  133. 	return 0;
  134. }

UVA572 Oil Deposits DFS求解的更多相关文章

  1. UVa572 Oil Deposits DFS求连通块

      技巧:遍历8个方向 ; dr <= ; dr++) ; dc <= ; dc++) || dc != ) dfs(r+dr, c+dc, id); 我的解法: #include< ...

  2. HDOJ(HDU).1241 Oil Deposits(DFS)

    HDOJ(HDU).1241 Oil Deposits(DFS) [从零开始DFS(5)] 点我挑战题目 从零开始DFS HDOJ.1342 Lotto [从零开始DFS(0)] - DFS思想与框架 ...

  3. Oil Deposits(dfs)

    Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)Total Submission( ...

  4. HDU 1241 Oil Deposits DFS(深度优先搜索) 和 BFS（广度优先搜索）

    Oil Deposits Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others) Total ...

  5. HDU 1241 Oil Deposits (DFS/BFS)

    Oil Deposits Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)Tota ...

  6. HDU-1241 Oil Deposits (DFS)

    Oil Deposits Time Limit : 2000/1000ms (Java/Other)   Memory Limit : 65536/32768K (Java/Other) Total ...

  7. HDU_1241 Oil Deposits(DFS深搜)

    Problem Description The GeoSurvComp geologic survey company is responsible for detecting underground ...

  8. UVa 572 Oil Deposits(DFS)

     Oil Deposits  The GeoSurvComp geologic survey company is responsible for detecting underground oil ...

  9. [POJ] 1562 Oil Deposits (DFS)

    Oil Deposits Time Limit: 1000MS   Memory Limit: 10000K Total Submissions: 16655   Accepted: 8917 Des ...

随机推荐

  1. C++内存管理2-内存泄漏

    1 C++中动态内存分配引发问题的解决方案 假设我们要开发一个String类,它可以方便地处理字符串数据.我们可以在类中声明一个数组,考虑到有时候字符串极长,我们可以把数组大小设为200,但一般的情况 ...

  2. 安装centos docker ce

    安装centos docker ce 移除旧的版本: $ sudo yum remove docker \ docker-client \ docker-client-latest \ docker- ...

  3. C++11 并发编程库

    C++11 并发编程 C++11 新标准中引入了几个头文件来支持多线程编程,他们分别是: <atomic>:该头文主要声明了两个类, std::atomic 和 std::atomic_f ...

  4. maven更改本地的maven私服

    1.今天想升级一个服务的jar包,更改后 使用命令 mvn deploy -e 一直报错, 看错误信息是  私服地址不是公司现在的地址. 想了半天,原来是电脑一直配置的上家公司的私服地址.. 但是在哪 ...

  5. hbase 操作

    视频随笔视频地址:hbase教程 1.与传统关系型数据库的区别 hbase 传统分布式   单机列动态增减   建表时候指定只有字符串一种数据类型   数值,字符空值不被存储   存储不支持SQL 查 ...

  6. sed取某域名对应的IP

  7. [转帖]Zookeeper

    Zookeeper https://www.cnblogs.com/zhang-qc/p/8877082.html   Zookeeper其实是一种为分布式应用所设计的高可用.高性能且一致的开源协调服 ...

  8. [Linux] 在 Ubuntu 19.10 上开启 SSH 服务并允许远程登录

    在 Ubuntu 19.10 上安装 SSH,并开启服务 0.检查并确认系统当前是否已安装SSH: sudo ps -e | grep ssh 如果只有 ssh-agent 说明 ssh-server ...

  9. CORS解决跨域问题（403问题）

    1.什么是跨域问题? 跨域问题是浏览器对于ajax请求的一种安全限制:一个页面发起的ajax请求,只能是用当前页同域名同端口的路径,这能有效的阻止跨站攻击. 2.跨域问题出现的条件: 1.跨域问题是a ...

  10. Keyboarding

    题目描述 思路 一开始想先写一个bfs,目标字符串要加上一个'*',表示这是一个换行符,然后一个字母一个字母的找,每次重置一下vis数组,bfs返回的结果再加上1,表示要打印这个字母,结果第一个样例没 ...