<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:
    int maxAreaOfIsland(vector<vector<int>>& grid) {
         
        int maxarea = 0, area = 0;
        set<pair<int,int>> visited;

        for(int i = 0; i < grid.size(); i++){
            for(int j = 0; j < grid[0].size(); j++){
                if(grid[i][j] == 1 && visited.find({i,j}) == visited.end()){
                    area = dfs(grid, i, j, visited);
                    maxarea = max(maxarea, area);
                }
            }
        }

        return maxarea;

    }


    int dfs(vector<vector<int>>& grid, int i, int j, set<pair<int,int>>& visited){
        stack<pair<int,int>> s;
        s.push({i,j});
        int count = 0;
        while(!s.empty()){
            int cx = s.top().first;
            int cy = s.top().second;
            s.pop();

            if(0 <= cx && cx < grid.size() && 0 <= cy && cy < grid[0].size()){
                if(visited.find({cx,cy}) == visited.end() && grid[cx][cy] == 1){
                    visited.insert({cx,cy});
                    count++;
                    s.push({cx, cy+1});
                    s.push({cx+1, cy});
                    s.push({cx, cy-1});
                    s.push({cx-1, cy});
                }
            }
        }
        return count;
    }
};
34230