牛客岛屿数量

题目：岛屿数量
题干：给一个01矩阵，1代表是陆地，0代表海洋， 如果两个1相邻，那么这两个1属于同一个岛。我们只考虑上下左右为相邻。
岛屿: 相邻陆地可以组成一个岛屿（相邻:上下左右） 判断岛屿个数。
例如：
输入
[
[1,1,0,0,0],
[0,1,0,1,1],
[0,0,0,1,1],
[0,0,0,0,0],
[0,0,1,1,1]
]
对应的输出为3
(注：存储的01数据其实是字符’0’,‘1’)

思路：
这题比较简单，就是一个递归调用的问题，1代表陆地，相邻的1属于同一个岛屿，也就是要找到一个为1的点a，然后向其四周进行搜索，找到为1的点b，然后继续由b点向四周搜索。不过这时候有个问题，那就是如果从a搜索到b，那b向四周搜索的时候，也能搜索到a。如果这样搜索，那岂不是陷入了死循环？所以得避免这种死循环，于是可以在搜索完成后，将a点置为0，这样在b点向四周搜索的时候就不会出现死循环了。
从上面的思路可见，其实就是用递归思想，实现一个深度优先的搜索而已。于是就可以开始着手实现代码了，不过还有一个问题，就是搜索的时候得保证每个点都在矩阵范围内，同时因为搜索的方式是固定的朝向四个方向，操作就是坐标（x，y）分别和{0,1}, {0,-1}, {1,0}, {-1,0}这四个组合进行运算。

代码：
C++：

#include <unistd.h>
#include <vector>
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 判断岛屿数量
     * @param grid char字符型vector<vector<>> 
     * @return int整型
     */
    vector<vector<int>> helper = {{0,1}, {0,-1}, {1,0}, {-1,0}};
    int solve(vector<vector<char> >& grid) {
        // write code here
        int col = grid[0].size();
        int row = grid.size();
        int res = 0;
        for(int i = 0; i < row; i++) {
            for(int j = 0; j < col; j++) {
                if(grid[i][j] == '1') {
                    fun(grid, i, j);
                    res ++;
                }
            }
        }
        return res;
    }

    void fun(vector<vector<char> >& grid, int row, int col) {
        if(grid[row][col] == '1') {
            grid[row][col] = '0';
        } else {
            return;
        }
        for(int i = 0; i < helper.size(); i++) {
            int col_temp = col + helper[i][1];
            int row_temp = row + helper[i][0];
            if(col_temp >= 0 && col_temp < grid[0].size() && row_temp >= 0
                && row_temp < grid.size()) {
                    fun(grid, row_temp, col_temp); 
            }
        }
    }
};

Java：这里要说下，java和c++不同之处就是c++能传递引用，java不能，但是传数组的时候，本来传递的就是数组首位的地址，意义和c++的传递引用也差不多，当时写的时候还想了一下，后来发现是多虑了。

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 判断岛屿数量
     * @param grid char字符型二维数组 
     * @return int整型
     */
    
    public void result(char[][] grid, int row, int col){
        int[][] dp = {{0,1}, {0,-1}, {1,0}, {-1,0}};
        if(grid[row][col] == '0'){
            //grid[row][col] = '0';
            return;
        }
        grid[row][col] = '0';
        for(int i = 0; i < dp.length; i++){
            int row_new = row + dp[i][0];
            int col_new = col + dp[i][1];
            if(row_new >= 0 && row_new < grid.length && col_new >= 0 && col_new < grid[0].length){
                result(grid, row_new, col_new);
            }
        }
        return;
    }
    public int solve (char[][] grid) {
        // write code here
        int row = grid.length;
        int col = grid[0].length;
        int res = 0;
        for(int i = 0; i < row; i++)
        {
            for(int j = 0; j < col; j++)
            {
                if(grid[i][j] == '1'){
                    result(grid,i,j);
                    res++;
                }
            }
        }
        return res;
    }
}