leetcode--200. 岛屿的个数

给定一个由 '1'（陆地）和 '0'（水）组成的的二维网格，计算岛屿的数量。一个岛被水包围，并且它是通过水平方向或垂直方向上相邻的陆地连接而成的。你可以假设网格的四个边均被水包围。

示例 1:

输入:
11110
11010
11000
00000

输出: 1

示例 2:

输入:
11000
11000
00100
00011

输出: 3

第一版：

其实是对的！！但是因为我把vis数组的赋值括号写成了{}导致一直出错。。。 枯了！

这种错误！！！！！

class Solution {    
    int d[4][2] = {{-1,0}, {1,0}, {0,-1}, {0,1}}; //方向数组
    
public:
    int numIslands(vector<vector<char>>& grid) {
        if (grid.empty()) return 0;
        
        int count = 0;
         //访问数组
        int row = grid.size();
        int col = grid[0].size();
        vector<vector<bool>> vis(row, vector<bool>(col,false));
        for(int i = 0; i < row; i++)
        {
            for(int j = 0; j < col; j++)
            {
                if(vis[i][j] == false && grid[i][j] == '1')  //没有被访问过，进行深搜
                {
                    dfs(i,j,grid,vis);
                    count++;
                }  
            }
        }   
        return count;
    }
    
    void dfs(int x, int y, vector<vector<char>>& grid, vector<vector<bool>>& vis)
    {
        int r = grid.size();
        int c = grid[0].size();
        
        if(x < 0 || x >= r || y < 0 || y >= c || grid[x][y] == '0' || vis[x][y] == true) return;
        vis[x][y] = true;
        
        for(int i = 0; i < 4; i++)
        {
            int dx = x + d[i][0];
            int dy = y + d[i][1];
            dfs(dx,dy,grid,vis);
        }
        
    }
};

 

我的 错误代码：

原因：广搜的数据量太大，导致溢出了。只过了14个点，还有就是，要记得空数组的判别

更新：也是对的，也是因为括号的原因....（佛）

class Solution {    
    int d[4][2] = {{-1,0}, {1,0}, {0,-1}, {0,1}}; //方向数组
    int count = 0;
    struct node
    {
        int x, y;
    }Node;
    
public:
    int numIslands(vector<vector<char>>& grid) {
        if(grid.empty() || grid[0].empty()) return 0;
         //访问数组
        int row = grid.size();
        int col = grid[0].size();
        vector<vector<bool>> vis(row, vector<bool>(col,false));
        
        for(int i = 0; i < row; i++)
        {
            for(int j = 0; j < col; j++)
            {
                if(grid[i][j] == '1' && vis[i][j] == false)
                {
                    count++;
                    bfs(i,j,grid,vis);
                }
            }
        }
        return count;
    }
    
    bool judge(int x, int y, vector<vector<char>>& grid, vector<vector<bool>>& vis)
    {
        int r = grid.size();
        int c = grid[0].size();
        if(x < 0 || x >= r || y < 0 || y >= c) return false;
        if(grid[x][y] == '0' || vis[x][y] == true) return false;
        return true;
    }
    
    void bfs(int x, int y, vector<vector<char>>& grid, vector<vector<bool>>& vis)
    {
        queue<node> Q;
        Node.x = x, Node.y = y;
        Q.push(Node);
        vis[x][y] = true;
        while(!Q.empty())
        {
            node top = Q.front();
            Q.pop();
            for(int i = 0; i < 4; i++)
            {
                int dx = top.x + d[i][0];
                int dy= top.y + d[i][1];
                if(judge(dx,dy,grid,vis))
                {
                    Node.x = dx, Node.y = dy;
                    Q.push(Node);
                    vis[dx][dy] = true;
                }
            }
        }
    }
};

 

大佬：cannon

 

class Solution {

private:
    int d[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
    int m, n;
    vector<vector<bool>> visited;

    bool inArea(int x, int y){
        return x >= 0 && x < m && y >= 0 && y < n;
    }

    // 从grid[x][y]的位置开始,进行floodfill
    // 保证(x,y)合法,且grid[x][y]是没有被访问过的陆地
    void dfs(vector<vector<char>>& grid, int x, int y){

        //assert(inArea(x,y));
        visited[x][y] = true;
        for(int i = 0; i < 4; i ++){
            int newx = x + d[i][0];
            int newy = y + d[i][1];
            if(inArea(newx, newy) && !visited[newx][newy] && grid[newx][newy] == '1')
                dfs(grid, newx, newy);
        }

        return;
    }

public:
    int numIslands(vector<vector<char>>& grid) {

        m = grid.size();
        if(m == 0)
            return 0;
        n = grid[0].size();
        if(n == 0)
            return 0;

        for(int i = 0 ; i < m ; i ++)
            visited.push_back(vector<bool>(n, false));

        int res = 0;
        for(int i = 0 ; i < m ; i ++)
            for(int j = 0 ; j < n ; j ++)
                if(grid[i][j] == '1' && !visited[i][j]){
                    dfs(grid, i, j);
                    res ++;
                }
        return res;
    }
};