floodfill算法 --leetcode 200_floodfill算法代码

题目描述

给定一个由 '1'（陆地）和 '0'（水）组成的的二维网格，计算岛屿的数量。一个岛被水包围，并且它是通过水平方向或垂直方向上相邻的陆地连接而成的。你可以假设网格的四个边均被水包围。

示例 1:

输入:
11110
11010
11000
00000

输出: 1

示例 2:

输入:
11000
11000
00100
00011

输出: 3

解题思路：

我们用棕色来表示陆地，蓝色来表示0水域，那么怎么找到陆地呢？我们首先从（0,0)点开始寻找， 用红色标记。

红色标记
是我们找到的第一个岛域，关键是我们应该怎样找到和它同属于同一个陆地的其它岛域。
当然可以采用深度优先遍历。具体来说我们从依次第一个标记的岛域上、下、左、右方向逐一寻找，然后不断回溯，直到找到同一陆地的所有岛屿，并都进行标记。最后返回到第一个点，便找到时到了与第一个点属于同一个陆域的所有岛域。


那么找到第一个陆地，我们如何找到其它陆地呢？如下图中红色域为我们找到的第一个陆地。我们可以从[0,1]点开始找未被标记且不是蓝色小域的岛域，以上面相同的方法找到和这个岛域同属于第二个陆地的岛屿，并进行标记。

c++ 代码

class Solution {
    
private:
    int d[4][2]={{0,1},{1,0},{0,-1},{-1,0}};
    int m, n;
    vector<vector<bool>> visited;
    
    bool inArea(int x, int y){
        return x>=0 && x< m && y >= 0 && y < n;
    }
    
    void dfs(vector<vector<char>>& grid , int x, int y){
      
        visited[x][y]=true;
        
        for(int i = 0; i<4 ;i++){
            int newx = x + d[i][0];
            int newy = y + d[i][1];
            
            if(inArea(newx,newy) && !visited[newx][newy]&&grid[newx][newy]=='1')
                //找到了一个与grid[x][y]属于同一陆地的一个岛域grid[newx,newy].
                //接下来寻找递规寻找与grid[newx][newy]同属同一陆地的岛域
                dfs(grid,newx,newy);
            
        }
        return;
    }
    
    
public:
 
    int numIslands(vector<vector<char>>& grid) {
        
        m = grid.size();
        
        if(m == 0)
            return 0;
        
        n = grid[0].size();
        if(n == 0)
            return 0;
        
        visited=vector<vector<bool>>(m,vector<bool>(n,false));
        
        int res = 0;
        
        
        for(int i=0;i<m;i++)
            for(int j=0;j<n;j++)
                if(grid[i][j]=='1'&& !visited[i][j])
                {
                    res++;
                    //接下来标记和grid[i][j]属于同一块陆地的所有岛域//
                    dfs(grid,i,j);
                }
        return res;
        
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

非递规实现c++

#include <iostream>
#include <vector>
#include <cassert>
#include <stack>

using namespace std;

/// Floodfill - DFS
/// Non-recursion implementation
///
/// Time Complexity: O(n*m)
/// Space Complexity: O(n*m)
class Solution {

private:
    int d[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
    int m, n;

public:
    int numIslands(vector<vector<char>>& grid) {

        m = grid.size();
        if(m == 0)
            return 0;
        n = grid[0].size();
        if(n == 0)
            return 0;

        vector<vector<bool>> visited(m, vector<bool>(n, false));

        int res = 0;
        for(int i = 0 ; i < m ; i ++)
            for(int j = 0 ; j < n ; j ++)
                if(grid[i][j] == '1' && !visited[i][j]){
                    dfs(grid, i, j, visited);
                    res ++;
                }
        return res;
    }

private:
    void dfs(vector<vector<char>>& grid, int x, int y, vector<vector<bool>>& visited){

        stack<pair<int, int>> q;
        q.push(make_pair(x, y));
        visited[x][y] = true;
        while(!q.empty()){
            int curx = q.top().first;
            int cury = q.top().second;
            q.pop();

            for(int i = 0; i < 4; i ++){
                int newX = curx + d[i][0];
                int newY = cury + d[i][1];
                if(inArea(newX, newY) && !visited[newX][newY] && grid[newX][newY] == '1'){
                    q.push(make_pair(newX, newY));
                    visited[newX][newY] = true;
                }
            }
        }

        return;
    }

    bool inArea(int x, int y){
        return x >= 0 && x < m && y >= 0 && y < n;
    }
};


int main() {

    vector<vector<char>> grid1 = {
            {'1','1','1','1','0'},
            {'1','1','0','1','0'},
            {'1','1','0','0','0'},
            {'0','0','0','0','0'}
    };
    cout << Solution().numIslands(grid1) << endl;
    // 1

    // ---

    vector<vector<char>> grid2 = {
            {'1','1','0','0','0'},
            {'1','1','0','0','0'},
            {'0','0','1','0','0'},
            {'0','0','0','1','1'}
    };
    cout << Solution().numIslands(grid2) << endl;
    // 3

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

相关题目 ：130