Leetcode 1020 飞地的数量

地址 https://leetcode-cn.com/problems/number-of-enclaves/

给出一个二维数组 A，每个单元格为 0（代表海）或 1（代表陆地）。

移动是指在陆地上从一个地方走到另一个地方（朝四个方向之一）或离开网格的边界。

返回网格中无法在任意次数的移动中离开网格边界的陆地单元格的数量。

示例 ：

输入：[[,,,],[,,,],[,,,],[,,,]]
输出：
解释：
有三个  被  包围。一个  没有被包围，因为它在边界上。
示例 ：

输入：[[,,,],[,,,],[,,,],[,,,]]
输出：
解释：
所有  都在边界上或可以到达边界。
 

提示：

 <= A.length <=
 <= A[i].length <=
 <= A[i][j] <=
所有行的大小都相同

这题目和之前的

POJ 2386 Lake Counting

poj 1979 Red and Black

基本一致  可以使用并查集和DFS完成

这里就换个思路 给个BFS版本 不过提交 就tle了 仅仅是提供个答案外的思路

class Solution {
public:
    int numEnclaves(vector<vector<int>>& A) {
        if (A.empty()) return ;
        int n = A.size();
        int m = A[].size();
        int ret = ;

        for (int i = ; i < n; i++) {
            for (int  j = ; j < m; j++) {
                if (i ==  || i == ( n - ) || j ==  || j == (m - )) {
                    if(A[i][j] ==)
                        bfs(A, i, j);
                }
            }
        }

        for (int i = ; i < n; i++) {
            for (int j = ; j < m; j++) {
                if (A[i][j] == ) {
                    ret++;
                }
            }
        }

        return ret;
    }

private:
    int bfs(vector<vector<int>>& A, int i, int j) {
        int cnt = ;
        queue<vector<int>> que;
        que.push({ i, j });
        int di[] = { , , , - };
        int dj[] = { , -, ,  };

        while (!que.empty()) {
            vector<int> cur(que.front());
            que.pop();
            cnt++;
            A[cur[]][cur[]] = ;

            for (int k = ; k < ; k++) {
                int ni = cur[] + di[k];
                int nj = cur[] + dj[k];

                if (valid(ni, nj, A.size(), A[].size()) && A[ni][nj] == ) {
                    que.push({ ni, nj });
                }
            }
        }
        return cnt;
    }

    bool valid(int i, int j, int n, int m) {
        return (i >=  && i < n && j >=  && j < m);
    }
};

ac code:

 class Solution {
 public:
     int addx[]; int addy[];

     void Dfs(vector<vector<int>>& A,int x ,int y)
     {
         if( x < || x>= A.size() || y < || y >= A[].size()) return;

         A[x][y] = ;

         for(int i =  ;i <;i++){
             int newx = x + addx[i];
             int newy = y + addy[i];

             if(newx>= && newx < A.size() && newy >= && newy< A[].size() && A[newx][newy] == )
                 Dfs(A,newx,newy);
         }

     }

     int numEnclaves(vector<vector<int>>& A) {
         if(A.empty() || A[].empty()) return ;
         addx[] = -;addx[] = ; addx[] = ;addx[] = ;
         addy[] = ;addy[] = ; addy[] = -;addy[] = ;
         for(int i = ;i<A.size();++i){
             for(int j = ; j< A[].size();++j){
                 if(i ==  || i == A.size()- ||  j ==  || j == A[].size()- ){
                     if(A[i][j] == ){
                         //边缘的元素 并且== 1
                         Dfs(A,i,j);
                     }
                 }
             }
         }    

         int count = ;
         for(int i = ;i<A.size();++i){
             for(int j = ; j< A[].size();++j){
                 if(A[i][j] == ) count++;
             }
         }    

         return count;
     }
 };