433、岛屿的个数

题目内容：

    给一个01矩阵，求不同的岛屿的个数。

    0代表海，1代表岛，如果两个1相邻，那么这两个1属于同一个岛。我们只考虑上下左右为相邻。

样例：

[

  [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个岛

代码：

class Solution {
public:
    /*
     * @param grid: a boolean 2D matrix
     * @return: an integer
     */
    
    int numIslands(vector<vector<bool>> &grid) {
        // write your code here
        
        int col = grid.size();
        
        if(0 == col) return 0;
        
        int row = grid[0].size();
        
        
        
        bool *flag = new bool[col * row];
        
        
        
        for(int i = 0; i < col; i++)
        {
            for(int j = 0; j < row; j++)
            {
                flag[i*col + j] = false; 
            }
        }
    
        int numCount = 0;
        int up, down, left, right;
        for(int i = 0; i < col; i++)
        {
            for(int j = 0; j < row; j++)
            {
                if(false == flag[i*col + j])
                {
                    numCount += painting(grid, flag, col, row, i, j);
                }
            }
        }
        
        //delete[] flag;     这个delete需要注释掉，但是应该是要delete[]....吐槽一下后台编译器QAQ
        flag = NULL;
        return numCount;
    }
    
    int  painting(vector<vector<bool>> &grid, bool flag[], int col, int row, int c_loc, int r_loc)
    {
        if(true == grid[c_loc][r_loc] && false == flag[c_loc * col + r_loc])    //第二个条件很重要，防止不停递归
        {
            flag[c_loc * col + r_loc] = true;
        
            int up_down_left_right;
            up_down_left_right = c_loc - 1;         //up
            if(up_down_left_right >= 0) painting(grid, flag, col, row, up_down_left_right, r_loc); 
        
            up_down_left_right = c_loc + 1;         //down
            if(up_down_left_right < col) painting(grid, flag, col, row, up_down_left_right, r_loc);
            
            up_down_left_right = r_loc - 1;         //left
            if(up_down_left_right >= 0) painting(grid, flag, col, row, c_loc, up_down_left_right);
            
            up_down_left_right = r_loc + 1;         //right
            if(up_down_left_right < row ) painting(grid, flag, col, row, c_loc, up_down_left_right);
            
            return 1;
        }
        return 0;
    }
};

基本思路：

根据传过来的矩阵大小，建立bool数组（一维数组，表示二维矩阵），初始化为false，然后遍历这个矩阵，发现bool数组为false的时候，进入涂色函数，函数主要使用递归。

首先判断这个点对应的二维矩阵上的点是否为1（是一个岛）：

是的话，将这个bool矩阵中对应的点涂色（设为true），递归查找上下左右周围的几个点（判断是否连载一起），这里注意一下几个边界的判断条件（函数传了六个参数，好吧，好像有点多QAQ），结果返回1；

否则，返回0

我还是想吐槽一下这个delete[]。。。。。我还以为一不小心又到了C++的秘境