83、岛屿的个数

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

示例 1:

输入:
11110
11010
11000
00000

输出: 1
示例 2:

输入:
11000
11000
00100
00011

输出: 3

使用bfs算法，当然也可以使用LRU

代码：

class Solution {
    public int numIslands(char[][] grid) {
    if(grid == null || grid.length == 0 || grid[0].length == 0){
			return 0;
		}
        int result = 0;
		int x[] = {0,0,1,-1};
		int y[] = {1,-1,0,0};
		for (int i = 0; i < grid.length; i++) {
			for (int j = 0; j < grid[i].length; j++) {
				if(grid[i][j] == '1'){
					System.out.println("ge");
					result ++;
					Queue<int[]> tem = new LinkedList<>();
					tem.offer(new int[]{i,j});
					while (!tem.isEmpty()) {
						int gets[] = tem.poll();
						int x1 = gets[0];
						int y1 = gets[1];
						for (int k = 0; k < 4; k++) {
							int temx = x[k] + x1;
							int temy = y[k] + y1;
							if(temx >= 0 && temx < grid.length && temy >= 0 && temy < grid[i].length){
								if(grid[temx][temy] == '1'){
									tem.offer(new int[]{temx,temy});
									grid[temx][temy] = '0';
								}
						}
						}
					}
				}		
			}
		}
		
		return result;
    }
}

dfs就是比bfs快

class Solution {
   public int numIslands(char[][] grid) {
		if(grid == null || grid.length == 0 || grid[0].length == 0){
			return 0;
		}
		
		
		int result = 0;
		
		int x[] = {0,0,1,-1};
		int y[] = {1,-1,0,0};
		for (int i = 0; i < grid.length; i++) {
			for (int j = 0; j < grid[i].length; j++) {
				if(grid[i][j] == '1'){
				
					result ++;
					dfs(grid, i, j);
				}
			}
		}
		
		return result;
        
    }
	public void dfs(char grid[][],int row,int col){
		if(row < 0 || row >= grid.length || col < 0 || col >= grid[0].length){
			return ;
		}
		
        if(grid[row][col] == '1'){
			grid[row][col] = '0';
			dfs(grid, row + 1, col);
			dfs(grid, row - 1, col);
			dfs(grid, row, col + 1);
			dfs(grid, row, col - 1);
		}
	}
}

LRU算法实现

class Solution {
 int result = 0;
	public int numIslands(char[][] grid) {
		if(grid == null || grid.length == 0 || grid[0].length == 0){
			return 0;
		}
		int x[] = {0,0,1,-1};
		int y[] = {1,-1,0,0};
		
		int m = grid.length;
		int n = grid[0].length;
		int root[] = new int[m * n];
//		初始化
		for (int i = 0; i < m; i++) {
			for (int j = 0; j < n; j++) {
				if(grid[i][j] == '1'){
					result ++;
					root[i * n + j] = i * n + j;
				}
			}
		}
		System.out.println(result);
//		进行合并操作
		for (int i = 0; i < m; i++) {
			for (int j = 0; j < n; j++) {
				if(grid[i][j] == '1'){
				//	grid[i][j] = '0';
					for (int k = 0; k < 4; k++) {
						int x1 = x[k] + i;
						int y1 = y[k] + j;
						if(x1 >= 0 && x1 < m && y1 >= 0 && y1 < n && grid[x1][y1] == '1'){
			//				result --;
							Unio(root, i * n + j, x1 * n + y1);
						}
					}
				}
			}
		}
		
		
		
		
		return result;
        
    }
	public void Unio(int [] root,int date1,int date2){
		int x1 = find(root,date1);
		int x2 = find(root, date2);
		if(x1 != x2 ){
			result --;
		}
		root[x1] = x2;
	}
	public int find(int root[],int date){
		return root[date] == date ? date:find(root, root[date]);
	}
	
}