岛屿的个数

用一个mark数组，和grid对应，初始化为0

DFS:

1.标记当前搜索位置已被搜索（标记当前位置的mark数组为1）

2.按照方向数组的4个方向，拓展4个新位置newx,newy

3.若新位置不在地图范围内，则忽略

4.如果新位置未曾到达（mark[newx][newy]=0,）且是陆地（grid[newx][newy]=1）,继续DFS这个位置

BFS:

1.设置搜索队列Q，标记mark[x][y]=1,并将待搜索的位置push队列Q

2.只要队列不空，取队头元素，按照方向数组的4个方向，拓展4个新位置newx,newy

3.若新位置不在地图范围内，则忽略

4.如果新位置未曾到达（mark[newx][newy]=0,）且是陆地（grid[newx][newy]='1'），将该新位置push进入队列，并标记mark[newx][newy]=1.

求岛屿的数量：

1.设置island_number = 0;

2.设置mark数组，并初始化

3.遍历地图grid上的所有点，如果当前点是陆地，且未被访问过，搜索search(mark,grid,x,y)，search是DFS或BFS。完成搜索后island_number++

class Solution {
public:
    //DFS
    void DFS(vector<vector<int> >& mark, vector<vector<char> >& grid,int x,int y)
    {
        mark[x][y] = 1;
        static const int dx[] = {-1, 1, 0, 0};
        static const int dy[] = {0, 0, -1, 1};//方向数组
        
        for(int i =0;i<4;++i)
        {
            int newx = x + dx[i];
            int newy = y + dy[i];
            
            if(newx <0 || newx >=mark.size() || newy<0 || newy>=mark[newx].size())
                continue;
            
            if(mark[newx][newy] ==0 && grid[newx][newy]== '1')
                DFS(mark,grid,newx,newy);
        }
    }
    
    //BFS
    void BFS(vector<vector<int> >& mark,vector<vector<char> >&grid,int x,int y)
    {
        static const int dx[] = {-1 , 1, 0, 0};
        static const int dy[] = {0, 0, -1 , 1};
        
        queue<pair<int,int> >q;
        q.push(make_pair(x,y));
        mark[x][y] = 1;
        
        while(!q.empty())
        {
            x = q.front().first;
            y = q.front().second;
            q.pop();
            for(int i = 0;i<4;++i)
            {
                int newx = x + dx[i];
                int newy = y + dy[i];
                if(newx <0 || newx >=mark.size() || newy<0 || newy>=mark[newx].size())
                    continue;
                
                if(mark[newx][newy] ==0 && grid[newx][newy]== '1')
                {
                    q.push(make_pair(newx,newy));
                    mark[newx][newy] = 1;
                }
            }
                
        }
    }
    
    int numIslands(vector<vector<char>>& grid) {
        int island_number = 0;
        vector<vector<int> >mark;
        //初始化mark数组
        for(int i =0;i<grid.size();++i)
        {
            mark.push_back(vector<int>());
            for(int j = 0;j<grid[i].size();++j)
                mark[i].push_back(0);
        }
        
        for(int x = 0;x<grid.size();++x)
        {
            for(int y = 0;y<grid[x].size();++y)
            {
                if(mark[x][y] == 0 && grid[x][y] == '1')
                {
                    DFS(mark,grid,x,y);
                    //BFS(mark,grid,x,y);
                    island_number++;
                }
            }
        }
        
        return island_number;
    }
};