Leetcode——695. 岛屿的最大面积

思路1：
第一种思路是利用方向数组和set集合来简化代码，不用判断坐标是否超过数组边界。但是也正是因为使用了太多类似于find的函数所以在算法时间复杂度分析相同的情况下，比第二种思路耗时要长一些。
时间复杂度为O(line*row)
line和row分别为行长和列长。

class Solution 
{
public:
    int maxAreaOfIsland(vector<vector<int>>& grid) 
    {
        set<pair<int,int> > s;
        int line=grid.size();
        int row=grid[0].size();
        for(int i=0;i<line;i++)
        {
            for(int j=0;j<row;j++)
            {
                if(grid[i][j]==1)
                {
                    s.insert(make_pair(i,j));
                }
            }
        }
        vector<pair<int,int> > dirs;
        dirs.push_back(make_pair(0,1));
        dirs.push_back(make_pair(1,0));
        dirs.push_back(make_pair(0,-1));
        dirs.push_back(make_pair(-1,0));
        int re=0;
        for(int i=0;i<line;i++)
        {
            for(int j=0;j<row;j++)
            {
                if(s.find(make_pair(i,j))!=s.end())
                {
                    int templength=1;
                    queue<pair<int,int> > tempqu;
                    s.erase(make_pair(i,j));
                    tempqu.push(make_pair(i,j));
                    while(tempqu.size()!=0)
                    {
                        for(int ii=0;ii<dirs.size();ii++)
                        {
                            if(s.find(make_pair(tempqu.front().first+dirs[ii].first,tempqu.front().second+dirs[ii].second))!=s.end())
                            {
                                tempqu.push(make_pair(tempqu.front().first+dirs[ii].first,tempqu.front().second+dirs[ii].second));
                                s.erase(make_pair(tempqu.front().first+dirs[ii].first,tempqu.front().second+dirs[ii].second));
                                templength++;
                            }
                        }    
                        tempqu.pop();
                    }
                    if(templength>re)
                    {
                        re=templength;
                    }
                }
            }
        }
        return re;
    }
};

思路二
这种思路直接使用数组，没有使用set等数据结构，可能易读性差一些，但是比较快。

class Solution {
    int dfs(vector<vector<int>>& grid, int cur_i, int cur_j) {
        if (cur_i < 0 || cur_j < 0 || cur_i == grid.size() || cur_j == grid[0].size() || grid[cur_i][cur_j] != 1)
            return 0;
        grid[cur_i][cur_j] = 0;
        int di[4] = {0, 0, 1, -1};
        int dj[4] = {1, -1, 0, 0};
        int ans = 1;
        for (int index = 0; index != 4; ++index) {
            int next_i = cur_i + di[index], next_j = cur_j + dj[index];
            ans += dfs(grid, next_i, next_j);
        }
        return ans;
    }
public:
    int maxAreaOfIsland(vector<vector<int>>& grid) {
        int ans = 0;
        for (int i = 0; i != grid.size(); ++i)
            for (int j = 0; j != grid[0].size(); ++j)
                ans = max(ans, dfs(grid, i, j));
        return ans;
    }
};