深度优先搜索--岛屿的最大面积+最大人工岛

岛屿的最大面积

给你一个大小为 m x n 的二进制矩阵 grid 。

岛屿 是由一些相邻的 1 (代表土地) 构成的组合，这里的「相邻」要求两个 1 必须在 水平或者竖直的四个方向上 相邻。你可以假设 grid 的四个边缘都被 0（代表水）包围着。

岛屿的面积是岛上值为 1 的单元格的数目。

计算并返回 grid 中最大的岛屿面积。如果没有岛屿，则返回面积为 0 。

输入：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]]
输出：6
解释：答案不应该是 11 ，因为岛屿只能包含水平或垂直这四个方向上的 1 。

深度优先搜索即可。找到一个可以的，直接进，搜到底，搜完就设零，避免重复走出不来

class Solution {
public:
    int mlen;int nlen;
    int maxSize(vector<vector<int>>& grid,int m,int n){
        if(m < 0 || m > mlen || n < 0 || n > nlen)  return 0; // 判断m,n的边界条件
        if(grid[m][n] == 0 || grid[m][n] == -1) return 0;// 判断当前点的状态
        grid[m][n] = -1;// 标记为已经访问
        return 1+ maxSize(grid,m-1,n) + maxSize(grid,m,n+1) + maxSize(grid,m+1,n) + maxSize(grid,m,n-1);//递归求解
    }
    int maxAreaOfIsland(vector<vector<int>>& grid) {
        mlen = grid.size() -1 ;
        nlen = grid[0].size() -1 ;
        int maxsize = 0;
        for(int i = 0 ;i <= mlen ;i++){
            for(int j = 0 ;j <= nlen ; j++){
                int size = maxSize(grid,i,j);
                if(size > maxsize)  maxsize = size;
            }
        }
        return maxsize;
    }
};

最大人工岛

给你一个大小为 n x n 二进制矩阵 grid 。最多 只能将一格 0 变成 1 。

返回执行此操作后，grid 中最大的岛屿面积是多少？

岛屿 由一组上、下、左、右四个方向相连的 1 形成。

输入: grid = [[1, 0], [0, 1]]
输出: 3
解释: 将一格0变成1，最终连通两个小岛得到面积为 3 的岛屿。

输入: grid = [[1, 1], [1, 0]]
输出: 4
解释: 将一格0变成1，岛屿的面积扩大为 4。

class Solution {
public:
    int largestIsland(vector<vector<int>>& grid) {
        int res = 0; int maxArea = 0;

        // 连通块的索引
        int index =2; 
        int n = grid.size();

        // frist 为 连通块的索引  second 为连通块的面积
        unordered_map<int,int>  m; 

        for(int i = 0 ;i < n ;i++ ){
            for(int j = 0 ; j < n ; j++){
                if(grid[i][j] == 1){
                    int a = area(grid,i,j,index);
                    maxArea = max(a,res);
                    m[index] = a;                    
                    ++index;
                }
            }   
        }

        int plusRes = 0;
        for(int i = 0 ; i < n ; i++){
            for(int j = 0 ; j < n ; j++){
                if(grid[i][j] == 0 ){
                    int plusarea = plusArea(grid,i,j,m);
                    plusRes = max(plusarea,plusRes);
                }
            }
        }
        plusRes = max(maxArea, plusRes);
        return plusRes;
    }
    
    int plusArea(vector<vector<int>>& grid,int x,int y,unordered_map<int,int>& m){
        if(!isArea(grid,x,y) || grid[x][y] != 0){
            return 0;
        }
        int size = 0;

        //使用set来对 index 进行了去重
        set<int> s;
        if( isArea(grid, x-1, y) && grid[x-1][y] >= 2 ){
            s.insert(grid[x-1][y]);
        }
        if( isArea(grid, x+1, y) && grid[x+1][y] >=2 ){
            s.insert(grid[x+1][y]);
        }
        if( isArea(grid, x, y-1) && grid[x][y-1] >=2 ){
            s.insert(grid[x][y-1]);
        }
        if( isArea(grid, x, y+1) && grid[x][y+1] >=2 ){
            s.insert(grid[x][y+1]);
        }
        for(auto num : s){
            size += m[num];
        }
        ++size;
        return size;
    }
    
    int area(vector<vector<int>>& grid,int x,int y, int index){
        if( !isArea(grid, x, y) ){
            return 0;
        }
        if( grid[x][y] != 1 ){ 
            return 0;
        }
        grid[x][y] = index;
        return 1
                + area(grid , x+1, y,index)
                + area(grid , x-1, y,index)
                + area(grid , x, y+1,index)
                + area(grid , x, y-1,index);
    }

    //判断索引是否合法
    bool isArea(vector<vector<int>>& grid, int x, int y){
        return 0<=x && x< grid.size() && 0 <= y && y < grid[0].size();
    }

};