433. 岛屿的个数

class Solution:
    """
    大致思路：
    1.主函数，循环grid，只要是True,就说明是新的岛屿，然后写一个dfs方法找寻该岛屿关联的所有岛屿
    """
    def numIslands(self, grid):
        # write your code here
        #dfs写法，递归找寻，一直关联查找
        if not grid: return 0
        
        len_x, len_y = len(grid), len(grid[0])
        count = 0 
        direction = [[0,1],[0,-1],[1,0],[-1,0]]
        
        #当前岛屿所关联的都会被找到，赋值False
        def dfs(x, y):
            #递归找寻，注意，当grid[x][y]是非岛屿的时候，也是不符合递归条件的
            if (x < 0 or y < 0 or x > len_x - 1 or y > len_y - 1 or not grid[x][y]):
                return 
            
            #当前岛屿递归找寻
            grid[x][y] = False
            
            dfs(x + 1, y)
            dfs(x - 1, y)
            dfs(x, y + 1)
            dfs(x, y - 1)
            
        #主函数
        for i in range(len_x):
            for j in range(len_y):
                if (grid[i][j]):
                    count += 1
                    #找寻该岛屿所关联的所有岛屿,都当做一个岛屿来看
                    dfs(i, j)
                    
        return count

class Solution:
    """
    @param grid: a boolean 2D matrix
    @return: an integer
    """
    def numIslands(self, grid):
        # write your code here
        #bfs写法,四周的找寻，放进队列里面，一直不停的找寻队列为岛屿的四周
        
        if not grid: return 0 
        
        len_x, len_y = len(grid), len(grid[0])
        count = 0 
        queue = []
        directon = [[1,0],[-1,0],[0,1],[0,-1]]
        
        def bfs(x, y):
            queue.append([x, y])
            
            while queue:
                pop_num = queue.pop(0)
                pop_x = pop_num[0]
                pop_y = pop_num[1]
                
                #四周的找寻
                for d in directon:
                    new_x = d[0] + pop_x 
                    new_y = d[1] + pop_y 
                    
                    #如果是这种情况，跳出处理
                    if (new_x < 0 or new_y < 0 or new_x > len_x - 1 or new_y > len_y - 1):
                        continue
                    
                    #否则判断是否是
                    if (grid[new_x][new_y]):
                        queue.append([new_x,new_y])
                        grid[new_x][new_y] = False 
        
        
        #主函数
        for i in range(len_x):
            for j in range(len_y):
                if (grid[i][j]):
                    count += 1 
                    #当前岛屿四周不停的找寻符合条件的,赋值False
                    bfs(i, j)
        
        return count