力扣200岛屿数量

题目一

力扣:200

思路 ：这类题DFS模板

1、这是图论里经典的一类网格题，它并不给你一个正常意义上的图，而是给你一个网格，网格上有数字，用不同的数字标记出来不同的位置，让你对不同的位置进行一系列的计算。
2、这种题最朴素的解法就是DFS
3、一定要明白，任何一个点，在这张网格上，都有四个前进方向，前后左右，所以每个点处DFS，要朝四个方向上进行。
5、这种题目一定记住，你扩充点的时候，就是按照四个方向扩充，不用考虑别的，扩充完之后，需要递归了，这时候，越界的点一定要排除出去。
6、递归不能无限制走下去，具体则么停止，要根据具体题意分析

代码

本题探究岛屿数量，换句人话，就是求有多少个“连成一片的1”（即通过上下左右能到达），我每发现一次1，都DFS找一次与他上下左右相邻的所有点（用上面的模板），再次发现1，说明这个1，是上一片1通过上下左右到不了的，也就是新大陆了，故DFS次数就是答案数。

DFS

注意：
1、这里就讨论一下递归停止条件，因为不能让递归无休止走下去，所以必须加上终止条件，所有路过的点都为其附上一个新的数2，当再次经过，就停止函数。这里不要赋值为0，我们只需要标记已经走过，但这还是陆地，不是大海，所以本身属性不可变。

class Solution {
public:
	int m = 0, n = 0;//行列数
	int ans = 0;
	vector<vector<char>>tmp;//临时地图

	void find_island(int i, int j) {//递归
		if (tmp[i][j] == '0' || tmp[i][j] == '2') {//出口
			return;
		}
		tmp[i][j] = '2';
		int new_i[4], new_j[4];//四个方向
		new_i[0] = i;
		new_j[0] = j + 1;
		new_i[1] = i + 1;
		new_j[1] = j;
		new_i[2] = i - 1;
		new_j[2] = j;
		new_i[3] = i;
		new_j[3] = j - 1;
		for (int k = 0; k < 4; k++) {
			if (new_i[k] < m&&new_j[k] < n&&new_i[k] >= 0 && new_j[k] >= 0) {//越界的不要
				find_island(new_i[k], new_j[k]);//递归新的点
			}
		}
		return;
	}

	int numIslands(vector<vector<char>>& grid) {
		m = grid.size();
		n = grid[0].size();
		tmp = grid;

		for (int i = 0; i < m; i++) {
			for (int j = 0; j < n; j++) {
				if (tmp[i][j] == '1') {
					find_island(i, j);
					ans++;
				}
			}
		}
		return ans;
	}
};

（所有代码均已在力扣上运行无误）

经测试，该代码运行情况是(经过多次测试所得最短时间)：

BFS

思路同上，把递归换成迭代，把原来是系统维护的栈，换成了自己维护的队列，产生的新点存到队列，直到队列为空结束。

class Solution {
public:

	int m = 0, n = 0;
	int sum = 0;

	int ans = 0;
	vector<vector<char>>tmp;

	void findIsland(int i, int j) {
		queue<pair<int, int>> item;
		tmp[i][j] = '0';
		item.push(pair<int, int>(i, j));//里面就一对数据使用pair
		int new_i[4], new_j[4];
		while (!item.empty()) {
			int last_i = item.front().first;
			int last_j = item.front().second;
			item.pop();
			new_i[0] = last_i;
			new_j[0] = last_j + 1;
			new_i[1] = last_i + 1;
			new_j[1] = last_j;
			new_i[2] = last_i - 1;
			new_j[2] = last_j;
			new_i[3] = last_i;
			new_j[3] = last_j - 1;
			for (int k = 0; k < 4; k++) {
				if (new_i[k] < m&&new_j[k] < n&&new_i[k] >= 0 && new_j[k] >= 0) {
					if (tmp[new_i[k]][new_j[k]] == '0') {//停止条件
						continue;
					}
					else {
						tmp[new_i[k]][new_j[k]] = '0';
						item.push(pair<int, int>(new_i[k], new_j[k]));//存新点
					}
				}
				else {
					continue;
				}
			}
		}
	}

	int numIslands(vector<vector<char>>& grid) {
		m = grid.size();
		n = grid[0].size();
		sum = m + n - 2;
		tmp = grid;

		for (int i = 0; i < m; i++) {
			for (int j = 0; j < n; j++) {
				if (tmp[i][j] == '1') {
					findIsland(i, j);
					ans++;
				}
			}
		}

		return ans;
	}
};

（所有代码均已在力扣上运行无误）

经测试，该代码运行情况是(经过多次测试所得最短时间)：