飞地的数量（DFS/BFS/并查集）

首先该题很明显的属于模板题，我们只需套入DFS与BFS的模板即可

思路上我们只需遍历边缘上的1（即只要在边缘上遇到1，我们就搜索所有与它相连的1），并且将它们都变成0，最后遍历整个数组，如果还没有变成1的就是飞地

        1.DFS

class Solution {
public://DFS
	int cn=0,n,m;
    int tx,ty,nextt[4][2]={{0,1},{1,0},{0,-1},{-1,0}};
    void dfs(vector<vector<int>>& grid,int x,int y)
    {
        if(grid[x][y]==1)
        {
        	grid[x][y]=0;
            for(int i=0;i<4;i++)
        {
            tx=x+nextt[i][0];
            ty=y+nextt[i][1];
            if(tx<0||ty<0||tx>=n||ty>=m)
            {
                continue;
            }
            dfs(grid,tx,ty);
        }
    }

    }
    int numEnclaves(vector<vector<int>>& grid) {
        n=grid.size();
        m=grid[0].size();
		for(int i=0;i<m;i++)
		{
			if(grid[0][i]==1)
			{
				dfs(grid,0,i);
			}
		}
		for(int i=0;i<m;i++)
		{
			if(grid[n-1][i]==1)
			{
				dfs(grid,n-1,i);
			}
		}
		for(int i=0;i<n;i++)
		{
			if(grid[i][0]==1)
			{
				dfs(grid,i,0);
			}
		}
		for(int i=0;i<n;i++)
		{
			if(grid[i][m-1]==1)
			{
				dfs(grid,i,m-1);
			}
		}
		for(int i=0;i<n;i++)
		{
			for(int j=0;j<m;j++)
			{
				if(grid[i][j]==1)
				{
					cn++;
				}
			}
		}
        return cn;
    }
};

         2.BFS

class Solution {
public://BFS
int cn = 0;
int n, m, tx, ty, nextt[4][2] = { {0,1},{1,0},{0,-1},{-1,0} };
queue<pair<int, int> >q;
void bfs(vector<vector<int>>& grid, int x, int y)
{
    pair<int, int> a, now, nt;
    a.first = x;
    a.second = y;
    q.push(a);
    while (!q.empty())
    {
        now = q.front();
        q.pop();
        if (grid[now.first][now.second] == 1)
        {
            grid[now.first][now.second] = 0;
            for (int i = 0; i < 4; i++)
            {
                tx = now.first + nextt[i][0];
                ty = now.second + nextt[i][1];
                if (tx < 0 || ty < 0 || tx >= n || ty >= m||grid[tx][ty]==0)
                {
                    continue;
                }
                nt.first = tx;
                nt.second = ty;
                q.push(nt);
            }
        }
    }

}
int numEnclaves(vector<vector<int>>& grid) {
    n = grid.size();
    m = grid[0].size();
    for (int i = 0; i < m; i++)
    {
        if (grid[0][i] == 1)
            bfs(grid, 0, i);
    }
    for (int i = 0; i < m; i++)
    {
        if (grid[n - 1][i] == 1)
            bfs(grid, n - 1, i);
    }
    for (int i = 0; i < n; i++)
    {
        if (grid[i][0] == 1)
            bfs(grid, i, 0);
    }
    for (int i = 0; i < n; i++)
    {
        if (grid[i][m - 1] == 1)
            bfs(grid, i, m - 1);
    }
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            if (grid[i][j] == 1)
            {
                cn++;
            }
        }
    }
    return cn;
}
};

        3.并查集

class Solution {
public:
class DSU//并查集
{
public:
   DSU(int n) : p(n)
   {
       for (int i = 0; i < n; ++i)//初始化
       {
           p[i] = i;
       }
   }
   // 查找并合并路径
   int find(int x)
   {
       if (p[x] != x) p[x] = find(p[x]);
       return p[x];
   }
   void Union(int x, int y)
   {
       p[find(x)] = find(y);
   }
   bool isSameSet(int x, int y)
   {
       return find(x) == find(y);
   }
private:
   vector<int> p;// 存储它的当前结点父辈结点
};
   int dx[4] = { 1, -1, 0, 0 };
   int dy[4] = { 0, 0, -1, 1 };
   int numEnclaves(vector<vector<int>>& grid)
   {
       //(i, j)结点映射到 i * n + j这个数
       int m = grid.size();
       int n = grid[0].size();
       DSU dsu(m * n + 10);//比我们需要的更大一点初始化才能与m*n相连
       for (int i = 0; i < m; ++i)
       {
           // (i, 0)和(i, n - 1)
           if (grid[i][0] == 1) 
               dsu.Union(i * n, m * n);        // 四个边界上的岛屿点都和 m * n 点相连
           if (grid[i][n - 1] == 1) 
               dsu.Union(i * n + n - 1, m * n);
       }
       for (int j = 0; j < n; ++j)
       {
           if (grid[0][j] == 1) 
               dsu.Union(j, m * n); // 四个边界上的岛屿点都和 m * n 点相连
           if (grid[m - 1][j] == 1) 
               dsu.Union((m - 1) * n + j, m * n);
       }
       for (int i = 0; i < m; ++i)
       {
           for (int j = 0; j < n; ++j)
           {
               if (grid[i][j] == 1)
               {
                   for (int k = 0; k < 4; ++k)//1的周围有1
                   {
                       int nx = i + dx[k];
                       int ny = j + dy[k];
                       if (nx < 0 || nx >= m || ny < 0 || ny >= n || grid[nx][ny] == 0)
                           continue;
                       // 否则设定它们彼此连通
                       dsu.Union(nx * n + ny, i * n + j);
                   }
               }
           }
       }
       // 经过这样一弄 所有与边上相连的岛屿点都连通到了m * n上
       // 检查和m * n不连通的即可
       int ret = 0;
       for (int i = 1; i < m - 1; ++i)
       {
           for (int j = 1; j < n - 1; ++j)
           {
               if (grid[i][j] == 1 && !dsu.isSameSet(i * n + j, m * n))
                   ++ret;
           }
       }
       return ret;
   };

};

 相比来说，并查集的代码效率更低一点

DFS（深度优先搜索算法）入门_ZZZWWWFFF_的博客-CSDN博客

BFS（广度优先搜索算法）入门_ZZZWWWFFF_的博客-CSDN博客

【算法与数据结构】—— 并查集_ZZZWWWFFF_的博客-CSDN博客