<p>You are given an <code>m x n</code> binary matrix <code>grid</code>. An island is a group of <code>1</code>&#39;s (representing land) connected <strong>4-directionally</strong> (horizontal or vertical.) You may assume all four edges of the grid are surrounded by water.</p>

<p>The <strong>area</strong> of an island is the number of cells with a value <code>1</code> in the island.</p>

<p>Return <em>the maximum <strong>area</strong> of an island in </em><code>grid</code>. If there is no island, return <code>0</code>.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2021/05/01/maxarea1-grid.jpg" style="width: 500px; height: 310px;" />
<pre>
<strong>Input:</strong> grid = [[0,0,1,0,0,0,0,1,0,0,0,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0],[0,1,1,0,1,0,0,0,0,0,0,0,0],[0,1,0,0,1,1,0,0,1,0,1,0,0],[0,1,0,0,1,1,0,0,1,1,1,0,0],[0,0,0,0,0,0,0,0,0,0,1,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0],[0,0,0,0,0,0,0,1,1,0,0,0,0]]
<strong>Output:</strong> 6
<strong>Explanation:</strong> The answer is not 11, because the island must be connected 4-directionally.
</pre>

<p><strong class="example">Example 2:</strong></p>

<pre>
<strong>Input:</strong> grid = [[0,0,0,0,0,0,0,0]]
<strong>Output:</strong> 0
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>m == grid.length</code></li>
	<li><code>n == grid[i].length</code></li>
	<li><code>1 &lt;= m, n &lt;= 50</code></li>
	<li><code>grid[i][j]</code> is either <code>0</code> or <code>1</code>.</li>
</ul>

class Solution {
public:
     vector<vector<int>>direction{{1,0},{0,1},{-1,0},{0,-1}};
    void dfs (vector<vector<int>>& grid ,vector<vector<bool>>&vis , int i , int j , int &count  )
    {
         if(i<0 || j<0 || i>=grid.size() || j>=grid[0].size() || vis[i][j]==true || grid[i][j]==0)
         {
            return ;
         }

         vis[i][j]=true;

         count++;
         int new_i=0;
         int new_j=0;  
         for( auto dir: direction)
         {
             new_i = i+dir[0];
             new_j = j+dir[1]; 

             dfs(grid , vis , new_i,new_j, count);
         }
    }  
    int maxAreaOfIsland(vector<vector<int>>& grid) {

        int m , n ;
        m= grid.size();
        n= grid[0].size();


        vector<vector<bool>>vis(m,vector<bool>(n,false));
        int maxi = 0 ;
        for(int i=0; i<m ;i++)
        {
             for(int j =0; j<n ; j++)
             {
                if(grid[i][j]==1 && vis[i][j]==false)
                {
                    int count =0 ; 
                    dfs(grid , vis , i ,j , count);
                  maxi=max(maxi,count);
                }
             }
        }
        return maxi ;
        
    }
};
34790