L200岛屿数量

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

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

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

示例 1:

输入:
11110
11010
11000
00000
输出: 1
示例 2:

输入:
11000
11000
00100
00011
输出: 3
解释: 每座岛屿只能由水平和/或竖直方向上相邻的陆地连接而成。

1.dfs方法
这里加了一个状态数组，但是每次循环，状态数组都会变化，所以并不是回溯

class Solution {
    int[][] mp = {{-1, 0}, {0, -1}, {1, 0}, {0, 1}};
    int n, m;
    public int numIslands(char[][] grid) {
        n = grid.length;
        if(n == 0) return 0;
        m = grid[0].length;
        int cnt = 0;
        //还是加上一个状态表示的
        boolean[][] sign = new boolean[n][m];//只是dfs，不需要回溯
        for(int i = 0; i < n; i++){
            for(int j = 0; j < m; j++){
                if(sign[i][j] == false && grid[i][j] == '1'){
                    cnt++;
                    dfs(grid, i, j, sign);
                }
            }
        }
        return cnt;
    }
    void dfs(char[][] grid, int i, int j, boolean[][] sign){
        sign[i][j] = true;
        for(int k = 0; k < 4; k++){
            int newX = i + mp[k][0];
            int newY = j + mp[k][1];
            if(newX >= 0 && newX < n && newY >= 0 && newY < m && grid[newX][newY] == '1' && sign[newX][newY] == false){
            //注意加上sign[newX][newY] == false，不然会爆栈
                dfs(grid, newX, newY, sign);
            }
        }
    }
}

2.bfs方法

import java.util.*;

class Solution {
    int[][] mp = {{-1, 0}, {0, -1}, {1, 0}, {0, 1}};
    int n,m;
    public int numIslands(char[][] grid) {
        n = grid.length;
        if(n == 0) return  0;
        m = grid[0].length;
        boolean[][] marked = new boolean[n][m];
        int cnt = 0;

        for(int i = 0; i < n; i++){
            for(int j = 0; j < m; j++){
                if(grid[i][j] == '1' && marked[i][j] == false){
                    cnt++;
                    marked[i][j] = true;//其实这个加不加都行，因为不会再访问到它
                    //dfs(grid, i, j, marked);
                    LinkedList<Integer> q = new LinkedList<>();//每次都要重新定义队列
                    q.add(i * m + j);//转换成一个数字存起来，或者就建立一个node节点类

                    while (!q.isEmpty()){
                        int now = q.poll();
                        int x = now / m;
                        int y = now % m;
                        //对四个方向进行遍历
                        for(int k = 0; k < 4; k++){
                            int newX = x + mp[k][0];
                            int newY = y + mp[k][1];

                            if(newX >= 0 && newY >= 0 && newX < n && newY < m
                                    && grid[newX][newY] == '1' && marked[newX][newY] == false){
                                q.add(newX * m + newY);
                                marked[newX][newY] = true;
                            }
                        }
                    }
                }
            }
        }
        return cnt;

    }
}