卡码网 99.计数孤岛（广搜 ，727）

26年7月27日，广度优先搜索bfs

package main
import(
    "fmt"
)
var n,m int
var dir=[4][2]int{{-1,0},{0,1},{1,0},{0,-1}}
func bfs(graph [][]int,visited [][]bool,x,y int){
    queue:=[][2]int{}
    queue=append(queue,[2]int{x,y})
    visited[x][y]=true
    for len(queue)>0{
        temp:=queue[0]
        queue=queue[1:]
        curx,cury:=temp[0],temp[1]
        for i:=0;i<4;i++{
        newx:=curx+dir[i][0]
        newy:=cury+dir[i][1]
        if newx<0||newx>=n||newy<0||newy>=m{
            continue
            //这里注意是continue,还有边界！！每次都写错
        }
         if graph[newx][newy]==1 && !visited[newx][newy]{
                visited[newx][newy]=true
                queue=append(queue,[2]int{newx,newy})
            }
        }
    }
}
func main(){
    res:=0
    fmt.Scanf("%d %d",&n,&m)
    graph:=make([][]int,n)
    for i:=range graph{
        graph[i]=make([]int,m)
        for j:=0;j<m;j++{
            fmt.Scanf("%d",&graph[i][j])
        }
    }
    visited:=make([][]bool,n)
    for i:=range visited{
        visited[i]=make([]bool,m)
        for j:=0;j<m;j++{
            visited[i][j]=false
        }
    }
    for i:=0;i<n;i++{
        for j:=0;j<m;j++{
            if graph[i][j]==1 && !visited[i][j]{
                res++
                bfs(graph,visited,i,j)
            }
        }
    }
    fmt.Println(res)
}

bfs思路

其实bfs，有点类似层序遍历，队列，这样的模型。反正就是一圈一圈的搜索，而不是先一条路走到黑再回溯

那么上面的就是维护一个队列，队列弹出队首时，队列加入其上下左右的数，这样循环，可以手动模拟一下能达到一层一层遍历的目的

另外就是用一个visted表来记录有没有被探索，只有没有被探索的地方我们才去。