leetcode 200. 岛屿数量 dfs,bfs,unique find

给你一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量。
岛屿总是被水包围，并且每座岛屿只能由水平方向或竖直方向上相邻的陆地连接形成。
此外，你可以假设该网格的四条边均被水包围。
 思路：这个图刚开始给我的感觉是和leetcode 547. 朋友圈的解法是一样的，直接将leetcode 547.的代码复制过来不对，检查原因是leetcode 547.是求图上的连通分量，比如如下数据：

[[1,1,1],
 [1,1,0],
 [0,0,1]]

 对于leetcode 547，结果应该是1，这是因为A是C的好朋友，则C一定也是A的好朋友，将他们化成一个无向图就可以理解。
 而leetcode 200，结果应该是2，所以leetcode 200并不能直接认为是图上的问题，但我们仍然可以利用和leetcode 547一样的三种方法解决。

dfs

class Solution {
public:
vector<int> dx = { 0,1,0,-1 };
vector<int> dy = { 1,0,-1,0 };
vector<vector<char>> g;
vector<vector<int>> vis;
//dfs  能用bfs的一般都不用回溯
void dfs(int i, int j,  int m, int n)
{
	for (int d = 0; d < 4; d++)
	{
		int ii = i + dx[d];
		int jj = j + dy[d];
		if (ii < 0 || ii >= m || jj < 0 || jj >= n) continue;
		if ( g[ii][jj] == '0') continue;
		if (vis[ii][jj] ==1) continue;
		vis[ii][jj] = 1;
		dfs(ii, jj, m, n);
	}
}
int numIslands(vector<vector<char>>& grid) {
    if(grid.empty()) return 0;
    int m = grid.size();
    if (m==0) return 0;
	int n = grid[0].size();
    if(m==0&&n==0) return 0;
	int ans = 0;
    g = grid;
    vis.assign(m,vector<int>(n,0));
	for (int i = 0; i < m; i++)
	{
		for (int j = 0; j < n; j++)
		{
			if (g[i][j] == '1'&&vis[i][j]==0)
			{
				ans++;
				vis[i][j] = 1;
				dfs(i, j, m, n);
			}
		}
	}
	return ans;
}
};

可以进行空间优化，不用vis数组，直接在源数组中将元素改变。

class Solution {
public:
vector<int> dx = { 0,1,0,-1 };
vector<int> dy = { 1,0,-1,0 };
//dfs  能用bfs的一般都不用回溯
void dfs(int i, int j,  int m, int n,vector<vector<char>>& g)
{
    g[i][j] = '0';
	for (int d = 0; d < 4; d++)
	{
		int ii = i + dx[d];
		int jj = j + dy[d];
		if (ii < 0 || ii >= m || jj < 0 || jj >= n) continue;
		if ( g[ii][jj] == '0') continue;
		//if (vis[ii][jj] ==1) continue;
		//vis[ii][jj] = 1;
		dfs(ii, jj, m, n,g);
	}
}
int numIslands(vector<vector<char>>& grid) {
	int m = grid.size();
    if (m==0) return 0;
	int n = grid[0].size();
    if(m==0&&n==0) return 0;
	int num = 0;
	for (int i = 0; i < m; i++)
	{
		for (int j = 0; j < n; j++)
		{
			if (grid[i][j] == '1')
			{
				num++;
				dfs(i, j, m, n, grid);
			}
		}
	}
	return num;
}
};

bfs

class Solution {
public:
//bfs
    vector<int> dx = { 0,1,0,-1 };
    vector<int> dy = { 1,0,-1,0 };
    int numIslands(vector<vector<char>>& grid) {
        if(grid.empty()) return 0;
        if(grid[0].size()==0)  return 0;
        int m=grid.size();
        int n=grid[0].size();
        vector<vector<int>> vis(m,vector<int>(n,0));
        queue<pair<int,int>> q;
        int ans=0;
        for(int i=0;i<m;i++)
        {
            for(int j=0;j<n;j++)
            {
                if(grid[i][j]=='1'&&vis[i][j]==0)
                {
                    vis[i][j]=1;
                    q.push(make_pair(i,j));
                    while(!q.empty())
                    {
                        auto[x,y]=q.front();
                        q.pop();
                        for (int d = 0; d < 4; d++)
	                    {    
                           int ii = x + dx[d];
		                   int jj = y + dy[d];
		                   if (ii < 0 || ii >= m || jj < 0 || jj >= n) continue;
		                   if ( grid[ii][jj] == '0') continue;
                           if (vis[ii][jj] == 1) continue;
                           q.push(make_pair(ii,jj));
                           vis[ii][jj] = 1;
                        }
                    }
                    ans++;
                }
            }
        }
        return ans;
    }
};

unique find

注意可以将二维的坐标转换位一维的，并且在使用father中，当$grid[i][j]={=}^{\prime }{0}^{\prime }$时，不应ans++;

class Solution {
public:
//bfs
   vector<int> dx = { 0,1,0,-1 };
vector<int> dy = { 1,0,-1,0 };
vector<int> father;
int find(int i) {
	int j = i;
	while (father[i] != i)
	{
		i = father[i];
	}
	while (father[j] != i)
	{
		father[j] = i;
	}
	return i;
}
void unique(int i, int j)
{
	int x = find(i);
	int y = find(j);
	if (x != y)
		father[y] = x;
}
int numIslands(vector<vector<char>>& grid) {
	if (grid.empty()) return 0;
	if (grid[0].size() == 0)  return 0;
	int m = grid.size();
	int n = grid[0].size();
	int ans = 0;
	for (int i = 0; i < m*n; i++)
	{
		father.push_back(i) ;
	}
	for (int i = 0; i < m; i++)
	{
		for (int j = 0; j < n; j++)
		{
			if (grid[i][j] == '1')
			{
				for (int d = 0; d < 4; d++)
				{
					int ii = i + dx[d];
					int jj = j + dy[d];
					if (ii < 0 || ii >= m || jj < 0 || jj >= n) continue;
					if (grid[ii][jj] == '1')
					{
						unique(i*n + j, ii*n + jj);
					}
				}
			}
			else ans--;//很重要
		}
	}
	for (int i = 0; i < m*n; i++)
	{
		if (father[i] == i)
			ans++;
	}
	return ans;
}
};