200. 岛屿数量

200. 岛屿数量

---

题目

给你一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量。

岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。

此外，你可以假设该网格的四条边均被水包围。

来源：力扣（LeetCode）
链接：leetcode200
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

---

一、思路

感觉没啥好讲的。就是一个dfs。
以每个结点为起始点开始dfs，搜过了就标记，四个方向都不能走了说明这一块所有连接的地方都走完了，返回主函数，ans++。

比如说，示例 1：

输入：grid = [
[“1”,“1”,“1”,“1”,“0”],
[“1”,“1”,“0”,“1”,“0”],
[“1”,“1”,“0”,“0”,“0”],
[“0”,“0”,“0”,“0”,“0”]
]
输出：1

（这里假设优先级是先右后下，这个取决于方向数组）
从（0，0）开始走，先往右走，走到（3，1）走不了了，return。此时回溯到（0，1），（0，1）往下走到（2，1）在往右再往上就到了（1，0），此时周边都走过了，回到主函数，ans++

二、最终代码（dfs）

代码如下（示例）：

class Solution {
public:
    int dir[5][3]={{0,0},{0,-1},{-1,0},{0,1},{1,0}};
    int ans=0;
    void dfs(vector<vector<char>>& matrix,int x,int y, vector<vector<int>>& dp)
    {
        int dx=0,dy=0;
		int m=matrix.size();
		int n=matrix[0].size();
        if(x>=m||x<0||y>=n||y<0)
        {
            return;
        }
        for(int i=1;i<=4;i++)
        {
            dx=x+dir[i][0];
        	dy=y+dir[i][1];
            if(dx<m&&dx>=0&&dy<n&&dy>=0&&!dp[dx][dy]&&matrix[dx][dy]=='1')
            {
                dp[dx][dy]=1;
                dfs(matrix,dx,dy,dp);
            }
        }
        return;
    }
    int numIslands(vector<vector<char>>& grid) {
        int m=grid.size();
        int n=grid[0].size();
        vector<vector<int>>dp(m,vector<int>(n,0));
        for(int i=0;i<m;i++)
        {
            for(int j=0;j<n;j++)
            {
                if(!dp[i][j]&&grid[i][j]=='1')
                {
                    dp[i][j]=1;
                    dfs(grid,i,j,dp);
                    ans++;
                }
            }
        }
        return ans;
    }
};

三、最终代码（bfs）

class Solution {
public:
    int dir[5][3]={{0,0},{0,-1},{-1,0},{0,1},{1,0}};
    int ans=0;
    void bfs(vector<vector<char>>& matrix,int x,int y, vector<vector<int>>& dp)
    {
        int dx=0,dy=0;
		int m=matrix.size();
		int n=matrix[0].size();
        queue<pair<int, int>> que;
        que.push({x, y});
        if(x>=m||x<0||y>=n||y<0)
        {
            return;
        }
        while (que.size() > 0) 
        {
            auto t = que.front();
            que.pop();
            for(int i=1;i<=4;i++)
            {
                dx=t.first+dir[i][0];
        	    dy=t.second+dir[i][1];
                if(dx<m&&dx>=0&&dy<n&&dy>=0&&!dp[dx][dy]&&matrix[dx][dy]=='1')
                {
                    que.push({dx,dy});
                    dp[dx][dy]=1;
                }
            }
        }
        return;
    }
    int numIslands(vector<vector<char>>& grid) {
        int m=grid.size();
        int n=grid[0].size();
        vector<vector<int>>dp(m,vector<int>(n,0));
        for(int i=0;i<m;i++)
        {
            for(int j=0;j<n;j++)
            {
                if(!dp[i][j]&&grid[i][j]=='1')
                {
                    dp[i][j]=1;
                    bfs(grid,i,j,dp);
                    ans++;
                }
            }
        }
        return ans;
    }
};

总结

就是个dfs，也不用回溯。
bfs也行，有空的话写写，主要懒得搞队列。
(update：bfs过了
救命，面试被问了并查集恰好没看，明天就把并查集写了呜呜呜