DFS和BFS求解岛屿数量

题目描述

给一个01矩阵，1代表是陆地，0代表海洋， 如果两个1相邻，那么这两个1属于同一个岛。我们只考虑上下左右为相邻。
岛屿: 相邻陆地可以组成一个岛屿（相邻:上下左右） 判断岛屿个数。

示例1
输入
[[1,1,0,0,0],[0,1,0,1,1],[0,0,0,1,1],[0,0,0,0,0],[0,0,1,1,1]]
返回值
3
备注:
01矩阵范围<=200*200

思路

先遍历所有节点找到节点值为1的，然后将当前节点的坐标传递给DFS或者BFS

DFS

递归三部曲

1.输入和返回值：输入二位数组以及它的行和列，当前节点为target点的坐标x,y，目标值taget;无输出
2.单层递归逻辑：每次都从当前位置开始向它的上下左右四个方法继续搜索
3.终止条件：当前的坐标受越界或者当前的值不等于target

 void backTrace(vector<vector<char>>& grid, int m, int n,int x ,int y)
    {
        //出界或者当前元素被访问过
        if(x < 0 || x >= m || y < 0 || y >= n || grid[x][y] != '1')
            return;
        grid[x][y] = '2';
        backTrace(grid, m, n, x + 1, y);    //右
        backTrace(grid, m, n, x - 1, y);    //左
        backTrace(grid, m, n, x, y - 1);    //上
        backTrace(grid, m, n, x, y + 1);    //下
    }
    
    int solve(vector<vector<char> >& grid) {
        // write code here
        if(grid.size() == 0)
            return 0;
        int m = grid.size();
        int n = grid[0].size();
        int result = 0;
        for(int i = 0; i < m; ++i)
        {
            for(int j = 0; j < n; ++j)
            {
                if(grid[i][j] == '1')
                {
                    backTrace(grid, m, n, i, j);
                    ++result;
                }
            }
        }
        return result;
    }

BFS

利用一个队列保存当前的坐标，然后遍历它的上下左右四个方向是否时1，是则将其加入队列，删除当前的坐标，并将其值该为2，直到队列为空则说明当前的岛屿找到

int dx[4] = { 0,0,-1,1 };
int dy[4] = { -1,1,0,0 };
void BFS(vector<vector<int> >& grid, int m, int n, int x, int y)
{
	queue<pair<int, int>> que;
	que.push(pair<int, int>(x, y));
	while (!que.empty())
	{
		pair<int, int> it = que.front();
		int _x = it.first;
		int _y = it.second;
		grid[_x][_y] = 2;
		que.pop();
		//当前值向四个方向移动
		for (int i = 0; i < 4; ++i)
		{
			int xx = _x + dx[i];
			int yy = _y + dy[i];
			if (xx < 0 || xx >= m || yy < 0 || yy >= n || grid[xx][yy] != 1) continue;
			que.push(pair<int, int>(xx, yy));
		}
	}
}
int solve(vector<vector<int> >& grid) {
	// write code here
	if (grid.size() == 0)
		return 0;
	int m = grid.size();
	int n = grid[0].size();
	int result = 0;
	for (int i = 0; i < m; ++i)
	{
		for (int j = 0; j < n; ++j)
		{
			if (grid[i][j] == 1)
			{
				BFS(grid, m, n, i, j);
				++result;
			}
		}
	}
	return result;
}