433 岛屿的个数

在矩阵：

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

中有 3 个岛.

思路：利用图像处理中区域生长的思想。

1.创建一个与grid相同大小值为0的矩阵tmp，用来保存生长后的结果。即tmp中同一个岛屿的坐标点对应数值一样。设置标签lable=0，该值记录岛屿编号。

2.遍历grid，如果当前点对应值为1且tmp相同点对应值为0，说明该点属于新岛屿，lable++，tmp=lable。同时，以该点为种子点进行4邻域生长。

3.生长过程借助栈，首先将上步种子点压入栈中。

如果种子点4邻域的某个点grid值为1且tmp值为0，说明该点待生长，将tmp赋值为lable，再将该点压入栈中。

重复上述生长过程直到栈为空，说明一个岛屿生长完毕。

最后返回lable。

AC代码：

class Solution {
public:
    /**
     * @param grid: a boolean 2D matrix
     * @return: an integer
     */
    int numIslands(vector<vector<bool>> &grid) {
        // write your code here
    int row=grid.size();
    if (row==0)
    {
        return 0;
    }
    int col=grid[0].size();
    if (col==0)
    {
        return 0;
    }
    vector<vector<int>> tmp(row,vector<int>(col,0));

    int neigb[4][2]={{0,-1},{-1,0},{0,1},{1,0}};
    stack<vector<int>> seedgrow;
    int lable=0;

    for (int i=0;i<row;i++)
    {
        for (int j=0;j<col;j++)
        {
            if (grid[i][j]==1&&tmp[i][j]==0)
            {
                lable++;
                tmp[i][j]=lable;
                vector<int> p;
                p.push_back(i);
                p.push_back(j);
                seedgrow.push(p);
                while(seedgrow.empty()==false)
                {
                    vector<int> seed=seedgrow.top();
                    seedgrow.pop();
                    for (int k=0;k<4;k++)
                    {
                        int x=seed[0]+neigb[k][0];
                        int y=seed[1]+neigb[k][1];
                        if ((x>=0&&x<row)&&(y>=0&&y<col))
                        {
                            if (grid[x][y]==1&&tmp[x][y]==0)//同时tmp[x][y]==0不可少，因为如果点(x,y)生长过了出现死循环;
                            {
                                tmp[x][y]=lable;
                                vector<int> newseed;
                                newseed.push_back(x);
                                newseed.push_back(y);
                                seedgrow.push(newseed);
                            }
                        }
                    }
                }
            }

        }
    }

    return lable;
    
    }
};

本题还可以用递归的方法来解决，都是深度优先搜索，递归的代码更简洁。

思路：二重循环遍历数组的每个点，如果值为true，计数器加1，然后判断该点的上下左右，如果上下左右某个点也为true，将其置为false，继续遍历这个点的上下左右……

代码：

void dfsInl(vector<vector<bool>> &grid,int i,int j)
{
    if (i<0||j<0||i>(int)grid.size()-1||j>(int)grid[0].size()-1)
    {
        return ;
    }
    if (grid[i][j]==true)//最开始没加这个判断导致栈溢出，蠢哭;
    {
        grid[i][j]=false;
        dfsInl(grid,i-1,j);
        dfsInl(grid,i+1,j);
        dfsInl(grid,i,j-1);
        dfsInl(grid,i,j+1);
    }

}

int numIslands(vector<vector<bool>> &grid)
{
    int row=grid.size();
    if (row==0)
    {
        return 0;
    }
    int col=grid[0].size();
    if (col==0)
    {
        return 0;
    }
    int result=0;
    for (int i=0;i<row;i++)
    {
        for (int j=0;j<col;j++)
        {
            if (grid[i][j]==true)
            {
                result++;
                dfsInl(grid,i,j);
            }
        }
    }
    return result;
}

参考：https://blog.csdn.net/u012762106/article/details/47866221

https://www.cnblogs.com/theskulls/p/4875599.html

https://blog.csdn.net/linside1022/article/details/79403018

https://blog.csdn.net/wutingyehe/article/details/47683513

433 岛屿的个数

描述

样例