Topic -Number of Islands
Just add this to the address of the Chinese website title (leetcode-cn)
Given a two-dimensional grid composed of '1'(land) and '0'(water), please count the number of islands in the grid. Islands are always surrounded by water, and each island can only be formed by connecting adjacent land in the horizontal or vertical direction.
In addition, you can assume that all four sides of the grid are surrounded by water.
Example 1:
输入:
11110
11010
11000
00000
输出: 1
Example 2:
输入:
11000
11000
00100
00011
输出: 3
解释: 每座岛屿只能由水平和/或竖直方向上相邻的陆地连接而成。
Methods: Depth first search (Shen Dao thought 1->0), breadth first search, combined search
Depth First Search (Chinese official)
class Solution {
public int numIslands(char[][] grid) {
if (grid == null || grid.length == 0) {
return 0;
}
int nr = grid.length;
int nc = grid[0].length;
int num_islands = 0;
for (int r = 0; r < nr; ++r) {
for (int c = 0; c < nc; ++c) {
if (grid[r][c] == '1') {
++num_islands;
dfs(grid, r, c);
}
}
}
return num_islands;
}
}
void dfs(char[][] grid, int r, int c) {
int nr = grid.length;
int nc = grid[0].length;
if (r < 0 || c < 0 || r >= nr || c >= nc || grid[r][c] == '0') {
return;
}
grid[r][c] = '0';
dfs(grid, r - 1, c);
dfs(grid, r + 1, c);
dfs(grid, r, c - 1);
dfs(grid, r, c + 1);
}
English official website most votes
- Python
def numIslands(self, grid):
if not grid:
return 0
count = 0
for i in range(len(grid)):
for j in range(len(grid[0])):
if grid[i][j] == '1':
self.dfs(grid, i, j)
count += 1
return count
def dfs(self, grid, i, j):
if i<0 or j<0 or i>=len(grid) or j>=len(grid[0]) or grid[i][j] != '1':
return
grid[i][j] = '#'
self.dfs(grid, i+1, j)
self.dfs(grid, i-1, j)
self.dfs(grid, i, j+1)
self.dfs(grid, i, j-1)
- Java
public class Solution {
private int n;
private int m;
public int numIslands(char[][] grid) {
int count = 0;
n = grid.length;
if (n == 0) return 0;
m = grid[0].length;
for (int i = 0; i < n; i++){
for (int j = 0; j < m; j++)
if (grid[i][j] == '1') {
DFSMarking(grid, i, j);
++count;
}
}
return count;
}
private void DFSMarking(char[][] grid, int i, int j) {
if (i < 0 || j < 0 || i >= n || j >= m || grid[i][j] != '1') return;
grid[i][j] = '0';
DFSMarking(grid, i + 1, j);
DFSMarking(grid, i - 1, j);
DFSMarking(grid, i, j + 1);
DFSMarking(grid, i, j - 1);
}
- Annotated
public class Solution {
int y; // The height of the given grid
int x; // The width of the given grid
char[][] g; // The given grid, stored to reduce recursion memory usage
/**
* Given a 2d grid map of '1's (land) and '0's (water),
* count the number of islands.
*
* This method approaches the problem as one of depth-first connected
* components search
* @param grid, the given grid.
* @return the number of islands.
*/
public int numIslands(char[][] grid) {
// Store the given grid
// This prevents having to make copies during recursion
g = grid;
// Our count to return
int c = 0;
// Dimensions of the given graph
y = g.length;
if (y == 0) return 0;
x = g[0].length;
// Iterate over the entire given grid
for (int i = 0; i < y; i++) {
for (int j = 0; j < x; j++) {
if (g[i][j] == '1') {
dfs(i, j);
c++;
}
}
}
return c;
}
/**
* Marks the given site as visited, then checks adjacent sites.
*
* Or, Marks the given site as water, if land, then checks adjacent sites.
*
* Or, Given one coordinate (i,j) of an island, obliterates the island
* from the given grid, so that it is not counted again.
*
* @param i, the row index of the given grid
* @param j, the column index of the given grid
*/
private void dfs(int i, int j) {
// Check for invalid indices and for sites that aren't land
if (i < 0 || i >= y || j < 0 || j >= x || g[i][j] != '1') return;
// Mark the site as visited
g[i][j] = '0';
// Check all adjacent sites
dfs(i + 1, j);
dfs(i - 1, j);
dfs(i, j + 1);
dfs(i, j - 1);
}
}