岛屿数量、岛屿面积，岛屿周长

岛屿数量
（1）、BFS

class Solution {
public:
    int numIslands(vector<vector<char>>& grid) {
        int rows = grid.size();
        if(rows == 0) return 0;
        int cols = grid[0].size();

        queue<pair<int, int>> que;

        int num_island = 0;
        for(int i = 0; i < rows; i++){
            for(int j = 0; j < cols; j++){
                if(grid[i][j] == '1'){
                    num_island++;
                    grid[i][j] = '2';
                    que.push({i, j});
                    while(!que.empty()){
                        auto x = que.front();
                        que.pop();
                        int r = x.first;
                        int c = x.second;
                        if(r - 1 >= 0 && grid[r - 1][c] == '1'){grid[r - 1][c] = '2'; que.push({r - 1, c});}
                        if(r + 1 < rows && grid[r + 1][c] == '1'){grid[r + 1][c] = '2'; que.push({r + 1, c});}
                        if(c - 1 >= 0 && grid[r][c - 1] == '1'){grid[r][c - 1] = '2'; que.push({r, c - 1});}
                        if(c + 1 < cols && grid[r][c + 1] == '1'){grid[r][c + 1] = '2'; que.push({r, c + 1});}
                    }
                }
            }
        }
        return num_island;
    }
};

（2）、DFS

class Solution {
	int numIslands(vector<vector<char>>& grid) {
        //dfs
        int rows = grid.size();
        if(rows == 0) return 0;
        int cols = grid[0].size();

        int num_islands = 0;
        for(int i = 0; i < rows; i++){
            for(int j = 0; j < cols; j++){
                if(grid[i][j] == '1'){
                    num_islands++;
                    dfs(grid, i, j);  // 这个函数就是遍历矩阵然后将陆地位置置2
                }
            }
        }
        return num_islands;
    }

    void dfs(vector<vector<char> >& grid, int r, int c){  // 放在dfs函数外面判断grid[m][n]是否满足情况
        int raws = grid.size();
        int cols = grid[0].size();
        
        grid[r][c] = '2';   // 陆地位置置2
        if(r - 1 >= 0 && grid[r - 1][c] == '1') dfs(grid, r - 1, c);    //up
        if(r + 1 < raws && grid[r + 1][c] == '1') dfs(grid, r + 1, c);    // down
        if(c - 1 >= 0 && grid[r][c - 1] == '1') dfs(grid, r, c - 1);
        if(c + 1 < cols && grid[r][c + 1] == '1') dfs(grid, r, c + 1);
    }
};

岛屿面积

int maxAreaOfIsland(vector<vector<int>>& grid){
        int rows = grid.size();
        int cols = grid[0].size();
        if(rows == 0) return 0;

        int max_area = 0;
        
        for(int i = 0; i < rows; i++){
            for(int j = 0; j < cols; j++){
                if(grid[i][j] == 1){
                    int area = dfs(grid, i, j);
                    max_area = max(area, max_area);
                }
            }
        }
        return max_area;
    }
    int dfs(vector<vector<int>>& grid, int i, int j){     // 放在dfs函数里面判断grid[m][n]是否满足情况
        int area = 1;
        if(i < 0 || i >= grid.size() || j < 0 || j >= grid[0].size() || grid[i][j] != 1) return 0;  // 只要排除了括号内的情况，就只剩下grid[i][j] == 1了，所以后面不需要在判断grid[i][j] == 1，这个函数只有 i,j 不满足条件时才会返回0，其他时候只会返回area=1，这就实现了每遇到grid[i][j] == 1就加1
        // if(grid[i][j] == 1) return 1;
        grid[i][j] = 2;

        area += dfs(grid, i - 1, j);
        area += dfs(grid, i + 1, j);
        area += dfs(grid, i, j - 1);
        area += dfs(grid, i, j + 1);
        return area;
    }

岛屿周长
(1) DFS

class Solution {
    constexpr static int dx[4] = {0, 1, 0, -1};
    constexpr static int dy[4] = {1, 0, -1, 0};
public:
    int dfs(int x, int y, vector<vector<int>> &grid, int n, int m) {   // 这里的 dfs 和岛屿数量的有点不一样，这个是找每个岛（每个为 1 的块）的周围的 4 个位置
        if (x < 0 || x >= n || y < 0 || y >= m || grid[x][y] == 0) {
            return 1;
        }
        if (grid[x][y] == 2) {
            return 0;
        }
        grid[x][y] = 2;
        int res = 0;
        for (int i = 0; i < 4; ++i) {
            int tx = x + dx[i];
            int ty = y + dy[i];
            res += dfs(tx, ty, grid, n, m);
        }
        return res;
    }
    int islandPerimeter(vector<vector<int>> &grid) {
        int n = grid.size(), m = grid[0].size();
        int ans = 0;
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < m; ++j) {
                if (grid[i][j] == 1) {
                    ans += dfs(i, j, grid, n, m);
                }
            }
        }
        return ans;
    }
};

或者可以写为

int dfs(int i, int j, vector<vector<int>> &grid, int raws, int cols) {   // 这里的 dfs 和岛屿数量的有点不一样，这个是找每个岛（每个为 1 的块）的周围的 4 个位置
        if(i < 0 || i >= raws || j < 0 || j >= cols || grid[i][j] == 0) return 1;  // 边界和值为0的时候就加1
        if(grid[i][j] == 2) return 0;
        grid[i][j] = 2;

        int ans = 0;
        ans += dfs(i - 1, j, grid, raws, cols);
        ans += dfs(i + 1, j, grid, raws, cols);
        ans += dfs(i, j - 1, grid, raws, cols);
        ans += dfs(i, j + 1, grid, raws, cols);
        return ans;

    }
    int islandPerimeter(vector<vector<int>> &grid) {
        int raws = grid.size(), cols = grid[0].size();
        int ans = 0;
        for (int i = 0; i < raws; i++) {
            for (int j = 0; j < cols; j++) {
                if (grid[i][j] == 1) {
                    ans += dfs(i, j, grid, raws, cols);
                }
            }
        }
        return ans;
    }

（2）暴力解法

class Solution {  // 此法适合只有一个岛的情况
public:
    int islandPerimeter(vector<vector<int>>& grid) {
        int raws = grid.size();
        if(raws == 0) return 0;
        int cols = grid[0].size();
        int perimeter = 0;

        for(int i = 0; i < raws; i++){
            for(int j = 0; j < cols; j++){
                if(grid[i][j] == 1){
                    if(i - 1 < 0 || grid[i - 1][j] == 0) perimeter++;
                    if(i + 1 >= raws || grid[i + 1][j] == 0) perimeter++;
                    if(j - 1 < 0 || grid[i][j - 1] == 0) perimeter++;
                    if(j + 1 >= cols || grid[i][j + 1] == 0) perimeter++;
                }
            }
        }
        return perimeter;
    }
};