【探索-中级算法】岛屿的个数

最开始想到的解决方法，就是借助一个辅助数组 boolean[][] map，其中 map[i][j]==true 表示该土地已经被访问过了，且再借助深度遍历，当遇到一块土地时，同时把与其相连的土地都给遍历掉。

public int numIslands(char[][] grid) {
    if (grid==null||grid.length==0||grid[0].length==0) return 0;
    boolean[][] map = new boolean[grid.length][grid[0].length];
    // map[i][j] 为 true 则表示遍历过了
    int count = 0;
    for (int i = 0; i < grid.length; i++) {
        for (int j = 0; j < grid[0].length; j++) {
            if (grid[i][j]=='1'&&!map[i][j]) {
                ++count;
                travers(grid, map, i, j);
            }
        }
    }
    return count;
}

public void travers(char[][] grid, boolean[][] map, int i, int j) {
    if (i < 0 || i >= grid.length || j < 0 || j >= grid[0].length) return;
    // 如果不是陆地，或者已经被遍历过了
    if (grid[i][j]=='0'||map[i][j]) return;
    map[i][j] = true;
    // 遍历周围
    travers(grid, map, i - 1, j);
    travers(grid, map, i + 1, j);
    travers(grid, map, i, j - 1);
    travers(grid, map, i, j + 1);
}

之后，看到提交的答案中，有一个更加快的提交，即借助原地算法，如果 grid[i][j] 被遍历了，则用一个非 0 和 1 的值（避免影响原本的判断）去设置，用于标记已经被遍历了。

// 直接使用原地算法，就不用开辟辅助空间
public int numIslands(char[][] grid) {
    if (grid==null||grid.length==0||grid[0].length==0) return 0;
    // map[i][j] 为 true 则表示遍历过了
    int count = 0;
    for (int i = 0; i < grid.length; i++) {
        for (int j = 0; j < grid[0].length; j++) {
            if (grid[i][j]=='1') {
                ++count;
                travers(grid, i, j);
            }
        }
    }
    return count;
}
private void travers(char[][] grid, int i, int j) {
    if (i < 0 || i >= grid.length || j < 0 || j >= grid[0].length) return;
    if (grid[i][j]=='0'||grid[i][j]=='2') return;
    grid[i][j] = '2';
    // 遍历周围
    travers(grid, i - 1, j);
    travers(grid, i + 1, j);
    travers(grid, i, j - 1);
    travers(grid, i, j + 1);
}

当然，最后脑洞开了一下，用迭代代替递归。不过请勿模仿，因为 grid 太大的话就会超时。不过皮一下很开心。

// 不用递归的话进行遍历的话，则可以用一个集合，存储该点与周围及其周围的周围的点，直到遍历完这个集合
public int numIslands(char[][] grid) {
    if (grid==null||grid.length==0||grid[0].length==0) return 0;
    LinkedList<Point> tmpPoints = new LinkedList<>();
    int count = 0;
    for (int i = 0; i < grid.length; i++) {
        for (int j = 0; j < grid[0].length; j++) {
            if (grid[i][j]=='1') {
                ++count;
                tmpPoints.offer(new Point(i, j));
                
                while (!tmpPoints.isEmpty()) {
                    Point point = tmpPoints.poll();
                    int tmpX = point.x;
                    int tmpY = point.y;
                    grid[tmpX][tmpY] = '2';
                    if ((tmpX-1)>=0&&grid[tmpX-1][tmpY]=='1') 
                    	tmpPoints.offer(new Point(tmpX - 1, tmpY));
                    if ((tmpX+1)<grid.length&&grid[tmpX+1][tmpY]=='1') 
                    	tmpPoints.offer(new Point(tmpX + 1, tmpY));
                    if ((tmpY-1)>=0&&grid[tmpX][tmpY-1]=='1') 
                    	tmpPoints.offer(new Point(tmpX , tmpY-1));
                    if ((tmpY+1)<grid[0].length&&grid[tmpX][tmpY+1]=='1') 
                    	tmpPoints.offer(new Point(tmpX , tmpY+1));
                }
            }
        }
    }
    return count;
}