（算法）岛屿的最⼤⾯积————＜递归＞

1. 题⽬链接：695.岛屿的最⼤⾯积 

2. 题⽬描述：

3. 算法思路：

• 遍历整个矩阵，每当遇到⼀块⼟地的时候，就⽤「深搜」或者「宽搜」将与这块⼟地相连的「整个 岛屿」的⾯积计算出来。

• 然后在搜索得到的「所有的岛屿⾯积」求⼀个「最⼤值」即可。

• 在搜索过程中，为了「防⽌搜到重复的⼟地」：

        ◦ 可以开⼀个同等规模的「布尔数组」，标记⼀下这个位置是否已经被访问过；

        ◦ 也可以将原始矩阵的1 修改成0 ，但是这样操作会修改原始矩阵。

4. 解法（深搜dfs）：

算法流程：

• 主函数内：

        a. 遍历整个数组，发现⼀块没有遍历到的⼟地之后，就⽤dfs ，将与这块⼟地相连的岛屿的⾯ 积求出来；

        b. 然后将⾯积更新到最终结果ret 中。

• 深搜函数dfs 中：

        a. 能够进到dfs 函数中，说明是⼀个没遍历到的位置；

        b. 标记⼀下已经遍历过，设置⼀个变量S = 1 （当前这个位置的⾯积为1 ），记录最终的⾯ 积； 

        c. 上下左右遍历四个位置：

▪ 如果找到⼀块没有遍历到的⼟地，就将与这块⼟地相连的岛屿⾯积累加到S 上；

        d. 循环结束后， S 中存的就是整块岛屿的⾯积，返回即可。 

C++算法代码： 

class Solution 
{
public:
    int dx[4] = { 1,0,-1,0 };
    int dy[4] = { 0,1,0,-1 };
    int temp[50][50] = { 0 };    //状态数组
    int m, n;    //行列数
    int max_num=0;  //最大岛屿大小
    int count=1;    //一个岛屿的数量
    int dfs(vector<vector<int>>& grid, int x, int y)
    {
        for (int i = 0; i < 4; i++)
        {
            int X = x + dx[i], Y = y + dy[i];
            //合法性判断
            if (X < 0 || X >= m || Y < 0 || Y >= n || temp[X][Y] || grid[X][Y] == 0)
            {
                continue;
            }
            //修改值
            temp[X][Y] = 1;
            count++;
            dfs(grid, X, Y);
        }
        return count;
    }
    int maxAreaOfIsland(vector<vector<int>>& grid) 
    {
        m=grid.size(),n=grid[0].size();
        for(int i=0;i<m;i++)
        {
            for(int j=0;j<n;j++)
            {
                //条件合适则数量加一
                if(grid[i][j]==1&&temp[i][j]==0)
                {
                    temp[i][j]=1;
                    max_num=max(max_num,dfs(grid,i,j));
                    count=1;
                }
            }
        }
        return max_num;
    }
};

 Java算法代码：

class Solution
{
	boolean[][] vis;
	int m, n;
	int[] dx = { 0, 0, -1, 1 };
	int[] dy = { 1, -1, 0, 0 };
	int count;
	public int maxAreaOfIsland(int[][] grid)
	{
		m = grid.length; n = grid[0].length;
		vis = new boolean[m][n];
		int ret = 0;
		for (int i = 0; i < m; i++)
			for (int j = 0; j < n; j++)
			{
				if (!vis[i][j] && grid[i][j] == 1)
				{
					count = 0;
					dfs(grid, i, j);
					ret = Math.max(ret, count);
				}
			}
		return ret;
	}
	public void dfs(int[][] grid, int i, int j)
	{
		count++;
		vis[i][j] = true;
		for (int k = 0; k < 4; k++)
		{
			int x = i + dx[k], y = j + dy[k];
			if (x >= 0 && x < m && y >= 0 && y < n && !vis[x][y] && grid[x][y]
				== 1)
				dfs(grid, x, y);
		}
	}
}