leetcode 探索 队列与栈 岛屿数量

题目

给你一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量。
岛屿总是被水包围，并且每座岛屿只能由水平方向或竖直方向上相邻的陆地连接形成。
此外，你可以假设该网格的四条边均被水包围。
示例 1:

输入:
11110
11010
11000
00000
输出: 1

示例 2:

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/number-of-islands

分析

就是探索连城一片的1的个数，采用广度优先搜索结合队列实现，Go中没有队列，采用slice实现，每次出队slice就重新赋值。你可以把注释掉的打印语句打开，方便理解。

除了BFS，我们还有DFS，DFS采用递归，也就是系统的调用栈来实现。

两者共同点，都需要标记已经被访问过的元素，虽然这里简化了，是直接将元素据标记为0达到的。看起来DFS要更为简洁明了，递归的思想，果然很强大，由于每次都处理相同的事情，那么只要编写处理一次的代码，再递归自己，即可解决。

解法

• 解法1 BFS

func numIslands(grid [][]byte) int {
    if len(grid) == 0{
        return 0
    }
    nr := len(grid)
    nc := len(grid[0])
    
    var numIsland = 0
    for r := range grid {
        // fmt.Printf("r: %d\n", r)
        for c := range grid[0] {
            // fmt.Printf("c: %d\n", c)
            
            if grid[r][c] == '1' {
                numIsland++
                grid[r][c] = '0'

                neighbors := make([]pair, 0)
                neighbors = append(neighbors, pair{r, c})
                for len(neighbors) != 0 {
                    front := neighbors[0]   // front
                    neighbors = neighbors[1:] // dequeue
                    row, col := front.first, front.second
                    // fmt.Printf("front: %d, %d\n", row,col)
                    if row - 1 >= 0 && grid[row-1][col] == '1' {
                        neighbors = append(neighbors, pair{row-1, col}) // enqueue
                        grid[row - 1][col] = '0' // 标记
                    }
                    if row + 1 < nr && grid[row+1][col] == '1' {
                        neighbors = append(neighbors, pair{row+1, col}) // enqueue
                        grid[row+1][col] = '0' // 标记
                    }
                    if col + 1 < nc && grid[row][col+1] == '1' {
                        neighbors = append(neighbors, pair{row, col+1}) // enqueue
                        grid[row][col+1] = '0' // 标记
                    }
                    if col - 1 >= 0 && grid[row][col-1] == '1' {
                        neighbors = append(neighbors, pair{row, col-1}) // enqueue
                        grid[row][col-1] = '0' // 标记
                    }
                    
                    // fmt.Printf("queue is: %v\n", neighbors)
                }
            }            
        }
    }
    
    return numIsland
}

type pair struct {
    first int
    second int
}

• 解法2 DFS

func numIslands(grid [][]byte) int {
    if len(grid) == 0{
        return 0
    }
    
    var numIsland = 0
    for r := range grid {
        // fmt.Printf("r: %d\n", r)
        for c := range grid[0] {
            // fmt.Printf("c: %d\n", c)
            // 深度优先遍历，当第一次进去遍历时候，各个方向会在遇到0之后回溯，所以第一次dfs会把所有相邻的1都访问过，并且标记为已访问
            // 这里是否已经访问，通过将其标记为0。当dfs返回时候，数组的第一部分，应该被标记为0了。
            if grid[r][c] == '1' {
                numIsland++
                dfs(grid, r, c)
                fmt.Printf("r,c: %d, %d, grid: %v\n", r, c, grid)
            }
        }
    }
    
    return numIsland
}

func dfs(grid [][]byte, row, col int){
    nr := len(grid)
    nc := len(grid[0])
    
    // 如果是目标就返回，这里的目标是数组的边界，以及是否需要访问，因为为1的话，不是岛屿。不需要继续探索其周边。
    if row < 0 || col < 0 || row >= nr || col >= nc || grid[row][col] == '0' {
        return
    }
    
    grid[row][col] = '0' // 标记为已经搜索过了
    dfs(grid, row-1, col)
    dfs(grid, row+1, col)
    dfs(grid, row, col-1)
    dfs(grid, row, col+1)
}