1. subject

Two dimensional matrix grid from 0 （ land ） and 1（ water ） form . The island is made up of the largest 4 Connected in two directions 0 Group composed of , The closed island is a completely 1 Surround （ Left 、 On 、 Right 、 Next ） The island of .

Please return to the number of closed Islands .

Example 1：

Input ：grid = [[1,1,1,1,1,1,1,0],[1,0,0,0,0,1,1,0],[1,0,1,0,1,1,1,0],[1,0,0,0,0,1,0,1],[1,1,1,1,1,1,1,0]]
Output ：2
explain ：
The islands in the gray area are closed Islands , Because the island is completely surrounded by water （ Namely be 1 The area surrounds ）.

Example 2：

Input ：grid = [[0,0,1,0,0],[0,1,0,1,0],[0,1,1,1,0]]
Output ：1

Example 3：

 Input ：grid = [[1,1,1,1,1,1,1],
             [1,0,0,0,0,0,1],
             [1,0,1,1,1,0,1],
             [1,0,1,0,1,0,1],
             [1,0,1,1,1,0,1],
             [1,0,0,0,0,0,1],
             [1,1,1,1,1,1,1]]
 Output ：2

Tips ：
1 <= grid.length, grid[0].length <= 100
0 <= grid[i][j] <=1

source ： Power button （LeetCode）
link ：https://leetcode-cn.com/problems/number-of-closed-islands

2. Ideas

（1）DFS
The problem is actually LeetCode_DFS_ secondary _200. Number of Islands This deformation problem , Just remove... From its foundation grid The islands that are not closed around the central bank can be .

3. Code implementation （Java）

// Ideas 1————DFS
class Solution {
    
    /*  take 200. The number of islands on the side of the island is deleted , You can get the number of closed Islands   But here's the thing , In this question '0' Representing land ,'1' It stands for sea water  */
    public int closedIsland(int[][] grid) {
    
        //res Keep the number of islands closed , The initial value is  0
        int res = 0;
        int m = grid.length;
        int n = grid[0].length;
        for (int i = 0; i < m; i++) {
    
            // hold grid The island on the left in the middle was submerged 
            dfs(grid, i, 0);
            // hold grid The island on the right in the middle was submerged 
            dfs(grid, i, n - 1);
        }
        for (int i = 0; i < n; i++) {
    
            // hold grid The island above the middle was submerged 
            dfs(grid, 0, i);
            // hold grid The lower island in the middle was submerged 
            dfs(grid, m - 1, i);
        }
        // Traverse grid, The remaining islands are closed 
        for (int i = 0; i < m; i++) {
    
            for (int j = 0; j < n; j++) {
    
                if (grid[i][j] == 0) {
    
                    // Find an island 
                    res++;
                    // Use DFS Submerge the island ( Including the adjacent land up, down, left and right )
                    dfs(grid, i, j);
                }
            }
        }
        return res;
    }

    // From the position (i, j) Start , Turn the land adjacent to it into sea water 
    public void dfs(int[][] grid, int i, int j) {
    
        int m = grid.length;
        int n = grid[0].length;
        // Judge boundary condition 
        if (i < 0 || j < 0 || i >= m || j >= n) {
    
            return;
        }
        if (grid[i][j] == 1) {
    
            // The current position is already sea water , Then return directly 
            return;
        }
        // Change the current position to sea water , Equivalent to using an array visited Record the traversed nodes 
        grid[i][j] = 1;
        // At the same time, it also submerges the land up, down, left and right 
        dfs(grid, i - 1, j);
        dfs(grid, i + 1, j);
        dfs(grid, i, j - 1);
        dfs(grid, i, j + 1);
    }
}