# LeetCode – Number of Islands (Java)

Given a 2-d grid map of ‘1’s (land) and ‘0’s (water), count the number of islands. An island is surrounded by water and is formed by connecting adjacent lands horizontally or vertically. You may assume all four edges of the grid are all surrounded by water.

Example 1:

```11110
11010
11000
00000
```

Java Solution 1 – DFS

The basic idea of the following solution is merging adjacent lands, and the merging should be done recursively.

Each element is visited once only. So time is O(m*n).

```public int numIslands(char[][] grid) { if(grid==null || grid.length==0||grid[0].length==0) return 0;   int m = grid.length; int n = grid[0].length;   int count=0; for(int i=0; i<m; i++){ for(int j=0; j<n; j++){ if(grid[i][j]=='1'){ count++; merge(grid, i, j); } } }   return count; }   public void merge(char[][] grid, int i, int j){ int m=grid.length; int n=grid[0].length;   if(i<0||i>=m||j<0||j>=n||grid[i][j]!='1') return;   grid[i][j]='X';   merge(grid, i-1, j); merge(grid, i+1, j); merge(grid, i, j-1); merge(grid, i, j+1); }```

Java Solution 2 – Union-Find

Time is O(m*n*log(k)).

```public int numIslands(char[][] grid) { if(grid==null || grid.length==0 || grid[0].length==0) return 0;   int m = grid.length; int n = grid[0].length;   int[] dx={-1, 1, 0, 0}; int[] dy={0, 0, -1, 1};   int[] root = new int[m*n];   int count=0; for(int i=0; i<m; i++){ for(int j=0; j<n; j++){ if(grid[i][j]=='1'){ root[i*n+j] = i*n+j; count++; } } }   for(int i=0; i<m; i++){ for(int j=0; j<n; j++){ if(grid[i][j]=='1'){ for(int k=0; k<4; k++){ int x = i+dx[k]; int y = j+dy[k];   if(x>=0&&x<m&&y>=0&&y<n&&grid[x][y]=='1'){ int cRoot = getRoot(root, i*n+j); int nRoot = getRoot(root, x*n+y); if(nRoot!=cRoot){ root[cRoot]=nRoot; //update previous node's root to be current count--; }   } } } } }   return count; }   public int getRoot(int[] arr , int i){ while(arr[i]!=i){ i = arr[arr[i]]; }   return i; }```

Check out Number of Island II.

### 10 thoughts on “LeetCode – Number of Islands (Java)”

1. very good approch but I found some bugs in your code, I refactored and this is what I got
For my input I have 5 islands

{{1, 1, 0, 0, 0},
{0, 1, 0, 0, 1},
{1, 0, 0, 1, 1},
{0, 0, 0, 0, 0},
{1, 0, 1, 0, 1}};
``` public static int countIslands(int[][] map) { if (map == null) { throw new IllegalArgumentException("Map cannot be null"); }```

``` int islandCount = 0; for (int r = 0; r < map.length; r++) // r for rows { for (int c = 0; c 0 && r<map.length-1 && map[r + 1][c - 1] == 1) || (r<map.length-1 && map[r + 1][c] == 1) || (c < map[0].length-1 && map[r][c + 1] == 1) || (r < map.length-1 && c < map[0].length-1 && map[r + 1][c + 1] == 1)) { continue; } islandCount++; } } return islandCount; } public static void main(String[] args) { int[][] mat = {{1, 1, 0, 0, 0}, {0, 1, 0, 0, 1}, {1, 0, 0, 1, 1}, {0, 0, 0, 0, 0}, {1, 0, 1, 0, 1}}; ```

``` System.out.println(countIslands(mat)); } ```

2. Could you share an example input of the case to which your solution might not work?

3. I think I have a much nicer solution on O(m*n) time complexity and O(1) additional space complexity.
The algorithm is simple:
Go from top left to bottom right.
If we’re on a land, check the 2 adjacent tiles, from left and on top.
If one of them are lands, then this land is part of an already counted island.
If both are not land, then we discovered a new land – increment.

``` int countIslands(int[][] map) { if (map == null) throw new IllegalArgumentException(â€œMap cannot be nullâ€);```

``` int islandCound = 0; for (int r = 0 ; r < map.length ; r++) // r for rows { for (int c = 0 ; c 0 && map[r][c-1] == 1) || (r > 0 && c < map[r-1].length && map[r-1][c] == 1)) { continue; } islandCound++; } } ```

``` return islandCound; } ```

4. int[] dx={-1, 1, 0, 0};
int[] dy={0, 0, -1, 1};

why are we having a hard coded array? can someone please explain why this is needed ?

5. What will be the space complexity of first solution (using DFS) ?

6. In the second method, complexity is m*n*log(k). What is k??

7. isn’t the time complexity of DFS O(m)+O(n) where m is number of vertices and n is number of edges.??

8. def num_islands():

visited = set()

islands = 0

for i in range(4):

for j in range(5):

if m[i][j] == 1:

if i == 0 and j == 0:

islands += 1

elif i == 0:

if m[i][j-1] == 1:

continue # we have visited this island

else:

islands += 1

else:

if (i-1,j-1) in visited or

(i-1,j+1) in visited or

(i-1,j) in visited or

(i,j-1) in visited:

continue

else:

islands += 1

print visited

return islands

9. It’s necessary to call merge(gird,i-1,j) and merge(grid,i,j-1).

e.g
11111
00100
00101 <- this guy cannot be achieved by merge(grid,i+1,j) or merge(grid,i,j+1)
00111

10. You don’t need to call `merge(grid, i - 1, j)` and `merge(grid, i, j - 1)`.